Agda 2.2.10 → 2.3.0

raw patch · 186 files changed

+19636/−10586 lines, 186 filesdep +hashabledep +hashtablesdep ~arraydep ~basedep ~bytestringnew-uploaderPVP ok

version bump matches the API change (PVP)

Dependencies added: hashable, hashtables

Dependency ranges changed: array, base, bytestring, containers, epic, filepath, haskell-src-exts, old-time, pretty, process, syb, zlib

API changes (from Hackage documentation)

- Agda.Auto.SearchControl: costAppExtraRef :: Int

- Agda.Auto.SearchControl: costIncrease :: Int

- Agda.Auto.SearchControl: costIotaStep :: Int

- Agda.Auto.SearchControl: prioAbsurdLambda :: Int

- Agda.Auto.SearchControl: prioCompBeta :: Int

- Agda.Auto.SearchControl: prioCompBetaStructured :: Int

- Agda.Auto.SearchControl: prioCompChoice :: Int

- Agda.Auto.SearchControl: prioCompCopy :: Int

- Agda.Auto.SearchControl: prioCompIota :: Int

- Agda.Auto.SearchControl: prioCompUnif :: Int

- Agda.Auto.SearchControl: prioCompareArgList :: Int

- Agda.Auto.SearchControl: prioInferredTypeUnknown :: Int

- Agda.Auto.SearchControl: prioNo :: Int

- Agda.Auto.SearchControl: prioNoIota :: Int

- Agda.Auto.SearchControl: prioTypeUnknown :: Int

- Agda.Auto.SearchControl: prioTypecheckArgList :: Int

- Agda.Compiler.Epic.AuxAST: pairwiseFilter :: [Bool] -> [a] -> [a]

- Agda.Compiler.Epic.AuxAST: type Tag = Int

- Agda.Compiler.Epic.AuxAST: type Var = String

- Agda.Compiler.Epic.CompileState: addDataDecl :: Monad m => [QName] -> Compile m ()

- Agda.Compiler.Epic.CompileState: conPars :: CompileState -> Map QName Int

- Agda.Compiler.Epic.CompileState: dataDecls :: CompileState -> Map QName Tag

- Agda.Compiler.Epic.CompileState: defDelayed :: CompileState -> Map QName Bool

- Agda.Compiler.Epic.CompileState: definitions :: CompileState -> Set Var

- Agda.Compiler.Epic.CompileState: getConPar :: MonadTCM m => QName -> Compile m Int

- Agda.Compiler.Epic.CompileState: getIrrFilter :: Monad m => QName -> Compile m IrrFilter

- Agda.Compiler.Epic.CompileState: irrFilters :: CompileState -> Map QName IrrFilter

- Agda.Compiler.Epic.CompileState: mainName :: CompileState -> Maybe QName

- Agda.Compiler.Epic.CompileState: putConPar :: Monad m => QName -> Int -> Compile m ()

- Agda.Compiler.Epic.CompileState: putIrrFilter :: Monad m => QName -> IrrFilter -> Compile m ()

- Agda.Compiler.Epic.CompileState: type IrrFilter = [Bool]

- Agda.Compiler.Epic.ConstructorIrrelevancy: constrIrr :: MonadTCM m => [Fun] -> Compile m [Fun]

- Agda.Compiler.Epic.ConstructorIrrelevancy: irrBranch :: MonadTCM m => Branch -> Compile m Branch

- Agda.Compiler.Epic.ConstructorIrrelevancy: irrExpr :: MonadTCM m => Expr -> Compile m Expr

- Agda.Compiler.Epic.ConstructorIrrelevancy: irrFilter :: Type -> IrrFilter

- Agda.Compiler.Epic.ConstructorIrrelevancy: irrFun :: MonadTCM m => Fun -> Compile m Fun

- Agda.Compiler.Epic.Erasure: DontKnow :: Relevancy

- Agda.Compiler.Epic.Erasure: Irr :: Relevancy

- Agda.Compiler.Epic.Erasure: Rel :: Relevancy

- Agda.Compiler.Epic.Erasure: data Relevancy

- Agda.Compiler.Epic.Erasure: instance Eq Relevancy

- Agda.Compiler.Epic.Erasure: instance Ord Relevancy

- Agda.Compiler.Epic.Erasure: instance Show Relevancy

- Agda.Compiler.Epic.Forcing: FoldState :: CompiledClauses -> (CompiledClauses -> CompiledClauses) -> [Maybe Term] -> Telescope -> Nat -> FoldState

- Agda.Compiler.Epic.Forcing: clauseToFix :: FoldState -> CompiledClauses

- Agda.Compiler.Epic.Forcing: clausesAbove :: FoldState -> CompiledClauses -> CompiledClauses

- Agda.Compiler.Epic.Forcing: constrType :: MonadTCM m => QName -> Compile m Type

- Agda.Compiler.Epic.Forcing: data FoldState

- Agda.Compiler.Epic.Forcing: foldM' :: Monad m => a -> [b] -> (a -> b -> m a) -> m a

- Agda.Compiler.Epic.Forcing: instance Show FoldState

- Agda.Compiler.Epic.Forcing: isIn :: MonadTCM m => Nat -> CompiledClauses -> Compile m Bool

- Agda.Compiler.Epic.Forcing: isInCase :: MonadTCM m => Nat -> (Nat, Case CompiledClauses) -> Compile m Bool

- Agda.Compiler.Epic.Forcing: isInTerm :: Nat -> Term -> Bool

- Agda.Compiler.Epic.Forcing: lift2 :: (MonadTrans t, Monad (t1 m), MonadTrans t1, Monad m) => m a -> t (t1 m) a

- Agda.Compiler.Epic.Forcing: modifyM :: MonadState a m => (a -> m a) -> m ()

- Agda.Compiler.Epic.Forcing: raiseFromCC :: Nat -> Nat -> CompiledClauses -> CompiledClauses

- Agda.Compiler.Epic.Forcing: removeForced :: MonadTCM m => CompiledClauses -> Type -> Compile m CompiledClauses

- Agda.Compiler.Epic.Forcing: substCC :: MonadTCM m => [Nat] -> CompiledClauses -> StateT FoldState (Compile m) CompiledClauses

- Agda.Compiler.Epic.Forcing: substCCBody :: Nat -> Term -> CompiledClauses -> CompiledClauses

- Agda.Compiler.Epic.Forcing: substsCCBody :: [Term] -> CompiledClauses -> CompiledClauses

- Agda.Compiler.Epic.Forcing: telePos :: FoldState -> Nat

- Agda.Compiler.Epic.Forcing: theTelescope :: FoldState -> Telescope

- Agda.Compiler.Epic.Forcing: unification :: FoldState -> [Maybe Term]

- Agda.Compiler.Epic.LambdaLift: lambdaLift :: MonadTCM m => [Fun] -> Compile m [Fun]

- Agda.Compiler.Epic.LambdaLift: lambdaLiftExpr :: MonadTCM m => Expr -> LL (Compile m) Expr

- Agda.Compiler.Epic.LambdaLift: lambdaLiftFun :: MonadTCM m => Fun -> LL (Compile m) Fun

- Agda.Compiler.Epic.LambdaLift: type LL = WriterT [Fun]

- Agda.Compiler.Epic.Primitive: primLists :: MonadTCM m => Compile m [Fun]

- Agda.Compiler.MAlonzo.Compiler: constructorArity :: MonadTCM tcm => QName -> tcm Nat

- Agda.Interaction.BasicOps: CmpTerms :: [Polarity] -> a -> [b] -> [b] -> OutputForm a b

- Agda.Interaction.BasicOps: data OutputForm' a b

- Agda.Interaction.BasicOps: getConstraint :: Int -> TCM (OutputForm Expr Expr)

- Agda.Interaction.BasicOps: instance (Pretty a, Pretty b) => Pretty (OutputForm' a b)

- Agda.Interaction.BasicOps: instance (ToConcrete a c, ToConcrete b d) => ToConcrete (OutputForm' a b) (OutputForm' c d)

- Agda.Interaction.BasicOps: instance Reify Constraint (OutputForm Expr Expr)

- Agda.Interaction.GhciTop: A :: a -> Lisp a

- Agda.Interaction.GhciTop: Cons :: (Lisp a) -> (Lisp a) -> Lisp a

- Agda.Interaction.GhciTop: L :: [Lisp a] -> Lisp a

- Agda.Interaction.GhciTop: Q :: (Lisp a) -> Lisp a

- Agda.Interaction.GhciTop: data Lisp a

- Agda.Interaction.GhciTop: instance Pretty String

- Agda.Interaction.GhciTop: instance Pretty a => Pretty (Lisp a)

- Agda.Interaction.GhciTop: instance Pretty a => Show (Lisp a)

- Agda.Interaction.GhciTop: response :: Lisp String -> String

- Agda.Interaction.Options: optUnreachableCheck :: PragmaOptions -> Bool

- Agda.Syntax.Abstract: Definition :: DeclInfo -> [TypeSignature] -> [Definition] -> Declaration

- Agda.Syntax.Abstract: ScopedDef :: ScopeInfo -> Definition -> Definition

- Agda.Syntax.Abstract: data Definition

- Agda.Syntax.Abstract: instance Data Definition

- Agda.Syntax.Abstract: instance HasRange Definition

- Agda.Syntax.Abstract: instance KillRange Definition

- Agda.Syntax.Abstract: instance Show Definition

- Agda.Syntax.Abstract: instance Typeable Definition

- Agda.Syntax.Abstract.Views: HeadCon :: [QName] -> Head

- Agda.Syntax.Abstract.Views: HeadDef :: QName -> Head

- Agda.Syntax.Abstract.Views: HeadVar :: Name -> Head

- Agda.Syntax.Abstract.Views: NonApplication :: Expr -> AppView

- Agda.Syntax.Abstract.Views: data Head

- Agda.Syntax.Abstract.Views: headToExpr :: Head -> Expr

- Agda.Syntax.Abstract.Views: instance HasRange Head

- Agda.Syntax.Common: ignoreForced :: Relevance -> Relevance

- Agda.Syntax.Common: irrelevant :: Bool -> Relevance

- Agda.Syntax.Common: makeIrrelevant :: Arg a -> Arg a

- Agda.Syntax.Common: makeRelevant :: Arg a -> Arg a

- Agda.Syntax.Concrete.Definitions: NiceDef :: Range -> [Declaration] -> [NiceTypeSignature] -> [NiceDefinition] -> NiceDeclaration

- Agda.Syntax.Concrete.Definitions: data NiceDefinition

- Agda.Syntax.Concrete.Definitions: instance Data NiceDefinition

- Agda.Syntax.Concrete.Definitions: instance HasRange NiceDefinition

- Agda.Syntax.Concrete.Definitions: instance Typeable NiceDefinition

- Agda.Syntax.Concrete.Name: isInfix :: Name -> Bool

- Agda.Syntax.Concrete.Name: isNonfix :: Name -> Bool

- Agda.Syntax.Concrete.Name: isPostfix :: Name -> Bool

- Agda.Syntax.Concrete.Name: isPrefix :: Name -> Bool

- Agda.Syntax.Concrete.Operators.Parser: infixP :: IsExpr e => ReadP e (NewNotation, Range, [e]) -> ReadP e e -> ReadP e e

- Agda.Syntax.Concrete.Operators.Parser: infixlP :: IsExpr e => ReadP e (NewNotation, Range, [e]) -> ReadP e e -> ReadP e e

- Agda.Syntax.Concrete.Operators.Parser: infixrP :: IsExpr e => ReadP e (NewNotation, Range, [e]) -> ReadP e e -> ReadP e e

- Agda.Syntax.Concrete.Operators.Parser: nonfixP :: IsExpr e => ReadP e (NewNotation, Range, [e]) -> ReadP e e -> ReadP e e

- Agda.Syntax.Concrete.Operators.Parser: postfixP :: IsExpr e => ReadP e (NewNotation, Range, [e]) -> ReadP e e -> ReadP e e

- Agda.Syntax.Concrete.Operators.Parser: postop :: IsExpr e => ReadP e (NewNotation, Range, [e]) -> ReadP e (e -> ReadP a e)

- Agda.Syntax.Concrete.Operators.Parser: prefixP :: IsExpr e => ReadP e (NewNotation, Range, [e]) -> ReadP e e -> ReadP e e

- Agda.Syntax.Concrete.Operators.Parser: preop :: IsExpr e => ReadP e (NewNotation, Range, [e]) -> ReadP e (e -> ReadP a e)

- Agda.Syntax.Internal: Clauses :: Maybe Clause -> Clause -> Clauses

- Agda.Syntax.Internal: Fun :: (Arg Type) -> Type -> Term

- Agda.Syntax.Internal: FunV :: (Arg Type) -> Term -> FunView

- Agda.Syntax.Internal: Lub :: Sort -> Sort -> Sort

- Agda.Syntax.Internal: MetaS :: MetaId -> Args -> Sort

- Agda.Syntax.Internal: NoBind :: ClauseBody -> ClauseBody

- Agda.Syntax.Internal: NoFunV :: Term -> FunView

- Agda.Syntax.Internal: Suc :: Sort -> Sort

- Agda.Syntax.Internal: absBody :: Abs a -> a

- Agda.Syntax.Internal: data Clauses

- Agda.Syntax.Internal: data FunView

- Agda.Syntax.Internal: funView :: Term -> FunView

- Agda.Syntax.Internal: instance Data Clauses

- Agda.Syntax.Internal: instance Eq Sort

- Agda.Syntax.Internal: instance Eq Term

- Agda.Syntax.Internal: instance Eq Type

- Agda.Syntax.Internal: instance Eq a => Eq (Abs a)

- Agda.Syntax.Internal: instance Eq a => Eq (Tele a)

- Agda.Syntax.Internal: instance HasRange Clauses

- Agda.Syntax.Internal: instance Ord Sort

- Agda.Syntax.Internal: instance Ord Term

- Agda.Syntax.Internal: instance Ord Type

- Agda.Syntax.Internal: instance Ord a => Ord (Abs a)

- Agda.Syntax.Internal: instance Ord a => Ord (Tele a)

- Agda.Syntax.Internal: instance Show Clauses

- Agda.Syntax.Internal: instance Typeable Clauses

- Agda.Syntax.Internal: maybeOriginalClause :: Clauses -> Maybe Clause

- Agda.Syntax.Internal: originalClause :: Clauses -> Clause

- Agda.Syntax.Internal: sLub :: Sort -> Sort -> Sort

- Agda.Syntax.Internal: telFromList :: [Arg (String, Type)] -> Telescope

- Agda.Syntax.Internal: telToList :: Telescope -> [Arg (String, Type)]

- Agda.Syntax.Internal: teleLam :: Telescope -> Term -> Term

- Agda.Syntax.Internal: translatedClause :: Clauses -> Clause

- Agda.Syntax.Literal: LitLevel :: Range -> Integer -> Literal

- Agda.Syntax.Scope.Base: importedNameSpace :: Access -> NameSpaceId

- Agda.Syntax.Scope.Base: scopeImported :: Scope -> NameSpace

- Agda.Syntax.Scope.Base: scopePrivate :: Scope -> NameSpace

- Agda.Syntax.Scope.Base: scopePublic :: Scope -> NameSpace

- Agda.Syntax.Translation.AbstractToConcrete: data TypeAndDef

- Agda.Syntax.Translation.AbstractToConcrete: instance [overlap ok] (ToConcrete a1 c1, ToConcrete a2 c2) => ToConcrete (a1, a2) (c1, c2)

- Agda.Syntax.Translation.AbstractToConcrete: instance [overlap ok] (ToConcrete a1 c1, ToConcrete a2 c2, ToConcrete a3 c3) => ToConcrete (a1, a2, a3) (c1, c2, c3)

- Agda.Syntax.Translation.AbstractToConcrete: instance [overlap ok] ToConcrete (Constr Constructor) Declaration

- Agda.Syntax.Translation.AbstractToConcrete: instance [overlap ok] ToConcrete (DontTouchMe a) a

- Agda.Syntax.Translation.AbstractToConcrete: instance [overlap ok] ToConcrete AsWhereDecls WhereClause

- Agda.Syntax.Translation.AbstractToConcrete: instance [overlap ok] ToConcrete Clause [Declaration]

- Agda.Syntax.Translation.AbstractToConcrete: instance [overlap ok] ToConcrete Declaration [Declaration]

- Agda.Syntax.Translation.AbstractToConcrete: instance [overlap ok] ToConcrete Expr Expr

- Agda.Syntax.Translation.AbstractToConcrete: instance [overlap ok] ToConcrete LHS LHS

- Agda.Syntax.Translation.AbstractToConcrete: instance [overlap ok] ToConcrete LamBinding LamBinding

- Agda.Syntax.Translation.AbstractToConcrete: instance [overlap ok] ToConcrete LetBinding [Declaration]

- Agda.Syntax.Translation.AbstractToConcrete: instance [overlap ok] ToConcrete ModuleName QName

- Agda.Syntax.Translation.AbstractToConcrete: instance [overlap ok] ToConcrete Name Name

- Agda.Syntax.Translation.AbstractToConcrete: instance [overlap ok] ToConcrete Pattern Pattern

- Agda.Syntax.Translation.AbstractToConcrete: instance [overlap ok] ToConcrete QName QName

- Agda.Syntax.Translation.AbstractToConcrete: instance [overlap ok] ToConcrete RHS (RHS, [Expr], [Expr], [Declaration])

- Agda.Syntax.Translation.AbstractToConcrete: instance [overlap ok] ToConcrete RangeAndPragma Pragma

- Agda.Syntax.Translation.AbstractToConcrete: instance [overlap ok] ToConcrete TypeAndDef [Declaration]

- Agda.Syntax.Translation.AbstractToConcrete: instance [overlap ok] ToConcrete TypedBinding TypedBinding

- Agda.Syntax.Translation.AbstractToConcrete: instance [overlap ok] ToConcrete TypedBindings TypedBindings

- Agda.Syntax.Translation.AbstractToConcrete: instance [overlap ok] ToConcrete [Declaration] [Declaration]

- Agda.Syntax.Translation.AbstractToConcrete: instance [overlap ok] ToConcrete a c => ToConcrete (Arg a) (Arg c)

- Agda.Syntax.Translation.AbstractToConcrete: instance [overlap ok] ToConcrete a c => ToConcrete (Named name a) (Named name c)

- Agda.Syntax.Translation.AbstractToConcrete: instance [overlap ok] ToConcrete a c => ToConcrete [a] [c]

- Agda.Syntax.Translation.ConcreteToAbstract: instance [overlap ok] ToAbstract NiceDefinition Definition

- Agda.Syntax.Translation.InternalToAbstract: instance Reify i a => Reify (Abs i) (Name, a)

- Agda.Termination.SparseMatrix: instance (Integral i, HasZero b, Pretty b) => Pretty (Matrix i b)

- Agda.Termination.SparseMatrix: instance (Ord i, Integral i, Enum i, CoArbitrary b, HasZero b) => CoArbitrary (Matrix i b)

- Agda.TypeChecking.Abstract: instance (Subst a, AbstractTerm a) => AbstractTerm (Abs a)

- Agda.TypeChecking.CompiledClause: compile :: Cls -> CompiledClauses

- Agda.TypeChecking.CompiledClause: compileClauses :: [Clauses] -> CompiledClauses

- Agda.TypeChecking.CompiledClause: nextSplit :: Cls -> Maybe Int

- Agda.TypeChecking.CompiledClause: splitC :: Int -> Cl -> Case Cl

- Agda.TypeChecking.CompiledClause: splitOn :: Int -> Cls -> Case Cls

- Agda.TypeChecking.CompiledClause: type Cl = ([Arg Pattern], ClauseBody)

- Agda.TypeChecking.CompiledClause: type Cls = [Cl]

- Agda.TypeChecking.Constraints: addNewConstraints :: MonadTCM tcm => Constraints -> tcm ()

- Agda.TypeChecking.Constraints: solveConstraints :: MonadTCM tcm => Constraints -> tcm Constraints

- Agda.TypeChecking.Conversion: equalArgs :: MonadTCM tcm => Type -> Args -> Args -> tcm Constraints

- Agda.TypeChecking.Empty: isEmptyTypeC :: MonadTCM tcm => Type -> tcm Constraints

- Agda.TypeChecking.Level: BlockedLevel :: Term -> LevelAtom

- Agda.TypeChecking.Level: ClosedLevel :: Integer -> PlusView

- Agda.TypeChecking.Level: Max :: [PlusView] -> LevelView

- Agda.TypeChecking.Level: MetaLevel :: MetaId -> Args -> LevelAtom

- Agda.TypeChecking.Level: NeutralLevel :: Term -> LevelAtom

- Agda.TypeChecking.Level: Plus :: Integer -> LevelAtom -> PlusView

- Agda.TypeChecking.Level: data LevelAtom

- Agda.TypeChecking.Level: data PlusView

- Agda.TypeChecking.Level: instance Eq LevelAtom

- Agda.TypeChecking.Level: instance Eq PlusView

- Agda.TypeChecking.Level: instance Ord LevelAtom

- Agda.TypeChecking.Level: instance Ord PlusView

- Agda.TypeChecking.Level: instance Show LevelAtom

- Agda.TypeChecking.Level: instance Show LevelView

- Agda.TypeChecking.Level: instance Show PlusView

- Agda.TypeChecking.Level: levelMax :: LevelKit -> Term -> Term -> Term

- Agda.TypeChecking.Level: levelSuc :: LevelKit -> Term -> Term

- Agda.TypeChecking.Level: levelType :: LevelKit -> Term

- Agda.TypeChecking.Level: levelZero :: LevelKit -> Term

- Agda.TypeChecking.Level: newtype LevelView

- Agda.TypeChecking.Level: unLevelAtom :: LevelAtom -> Term

- Agda.TypeChecking.Level: unLevelView :: MonadTCM tcm => LevelView -> tcm Term

- Agda.TypeChecking.MetaVars: (=:) :: (MonadTCM tcm, HasMeta t, KillRange t, Show t) => MetaId -> t -> tcm ()

- Agda.TypeChecking.MetaVars: (=:=) :: MonadTCM tcm => MetaId -> Term -> tcm ()

- Agda.TypeChecking.MetaVars: abortAssign :: MonadTCM tcm => tcm a

- Agda.TypeChecking.MetaVars: assignS :: MonadTCM tcm => MetaId -> Args -> Sort -> tcm Constraints

- Agda.TypeChecking.MetaVars: assignSort :: MonadTCM tcm => MetaId -> Sort -> tcm ()

- Agda.TypeChecking.MetaVars: checkArgs :: MonadTCM tcm => MetaId -> Args -> FVs -> tcm [Arg Nat]

- Agda.TypeChecking.MetaVars: class HasMeta t

- Agda.TypeChecking.MetaVars: handleAbort :: MonadTCM tcm => TCM a -> TCM a -> tcm a

- Agda.TypeChecking.MetaVars: instance HasMeta Sort

- Agda.TypeChecking.MetaVars: instance HasMeta Term

- Agda.TypeChecking.MetaVars: isVar :: Arg Term -> Bool

- Agda.TypeChecking.MetaVars: metaInstance :: (HasMeta t, MonadTCM tcm) => t -> tcm MetaInstantiation

- Agda.TypeChecking.MetaVars: metaVariable :: HasMeta t => MetaId -> Args -> t

- Agda.TypeChecking.MetaVars: validParameters :: Monad m => Args -> FVs -> m [Arg Nat]

- Agda.TypeChecking.Monad.Base: AbortAssign :: TCState -> TCErr'

- Agda.TypeChecking.Monad.Base: ArgsCmp :: [Polarity] -> Type -> Args -> Args -> Constraint

- Agda.TypeChecking.Monad.Base: ScopeCheckDefinition :: NiceDefinition -> (Maybe Definition) -> Call

- Agda.TypeChecking.Monad.Base: axEpDef :: Defn -> Maybe EpicCode

- Agda.TypeChecking.Monad.Base: axHsDef :: Defn -> Maybe HaskellRepresentation

- Agda.TypeChecking.Monad.Base: conHsCode :: Defn -> Maybe (HaskellType, HaskellCode)

- Agda.TypeChecking.Monad.Base: dataHsType :: Defn -> Maybe HaskellType

- Agda.TypeChecking.Monad.Base: envIrrelevant :: TCEnv -> Bool

- Agda.TypeChecking.Monad.Base: envReplace :: TCEnv -> Bool

- Agda.TypeChecking.Monad.Base: stConstraints :: TCState -> Constraints

- Agda.TypeChecking.Monad.Base: type ConstraintClosure = Closure Constraint

- Agda.TypeChecking.Monad.Builtin: builtinTypes :: [String]

- Agda.TypeChecking.Monad.Builtin: getBuiltinThings :: MonadTCM tcm => tcm (BuiltinThings PrimFun)

- Agda.TypeChecking.Monad.Builtin: primAgdaTerm :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primAgdaTermCon :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primAgdaTermDef :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primAgdaTermLam :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primAgdaTermPi :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primAgdaTermSort :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primAgdaTermUnsupported :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primAgdaTermVar :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primArg :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primArgArg :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primBool :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primChar :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primCons :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primEquality :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primFalse :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primFlat :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primFloat :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primIO :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primInf :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primInteger :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primLevel :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primLevelMax :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primLevelSuc :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primLevelZero :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primList :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primNat :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primNatDivSucAux :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primNatEquality :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primNatLess :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primNatMinus :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primNatModSucAux :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primNatPlus :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primNatTimes :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primNil :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primQName :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primRefl :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primSharp :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primSize :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primSizeInf :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primSizeSuc :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primString :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primSuc :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primTrue :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Builtin: primZero :: MonadTCM tcm => tcm Term

- Agda.TypeChecking.Monad.Constraints: addConstraints :: MonadTCM tcm => Constraints -> tcm ()

- Agda.TypeChecking.Monad.Constraints: getConstraints :: MonadTCM tcm => tcm Constraints

- Agda.TypeChecking.Monad.Constraints: lookupConstraint :: MonadTCM tcm => Int -> tcm ConstraintClosure

- Agda.TypeChecking.Monad.Constraints: takeConstraints :: MonadTCM tcm => tcm Constraints

- Agda.TypeChecking.Monad.Context: applyRelevanceToContext :: MonadTCM tcm => Relevance -> tcm a -> tcm a

- Agda.TypeChecking.Monad.Context: wakeIrrelevantVars :: MonadTCM tcm => tcm a -> tcm a

- Agda.TypeChecking.Monad.Imports: preserveDecodedModules :: TCM a -> TCM a

- Agda.TypeChecking.Pretty: comma :: MonadTCM tcm => tcm Doc

- Agda.TypeChecking.Pretty: empty :: MonadTCM tcm => tcm Doc

- Agda.TypeChecking.Primitive: (<#>) :: MonadTCM tcm => tcm Term -> tcm Term -> tcm Term

- Agda.TypeChecking.Primitive: (<@>) :: MonadTCM tcm => tcm Term -> tcm Term -> tcm Term

- Agda.TypeChecking.Primitive: hPi :: MonadTCM tcm => String -> tcm Type -> tcm Type -> tcm Type

- Agda.TypeChecking.Primitive: nPi :: MonadTCM tcm => String -> tcm Type -> tcm Type -> tcm Type

- Agda.TypeChecking.Reduce: instance InstantiateFull Clauses

- Agda.TypeChecking.Reduce: instance InstantiateFull a => InstantiateFull (Tele a)

- Agda.TypeChecking.Reduce: instance InstantiateFull t => InstantiateFull (Abs t)

- Agda.TypeChecking.Reduce: instance Normalise a => Normalise (Tele a)

- Agda.TypeChecking.Reduce: instance Normalise t => Normalise (Abs t)

- Agda.TypeChecking.Reduce: instance Reduce t => Reduce (Abs t)

- Agda.TypeChecking.Rules.Builtin: bindBuiltinBool :: String -> Expr -> TCM Term

- Agda.TypeChecking.Rules.Builtin: bindBuiltinCons :: Expr -> TCM Term

- Agda.TypeChecking.Rules.Builtin: bindBuiltinDummyConstructor :: Expr -> TCM Term

- Agda.TypeChecking.Rules.Builtin: bindBuiltinEquality :: Expr -> TCM ()

- Agda.TypeChecking.Rules.Builtin: bindBuiltinNil :: Expr -> TCM Term

- Agda.TypeChecking.Rules.Builtin: bindBuiltinPrimitive :: String -> String -> Expr -> (Term -> TCM ()) -> TCM ()

- Agda.TypeChecking.Rules.Builtin: bindBuiltinRefl :: Expr -> TCM Term

- Agda.TypeChecking.Rules.Builtin: bindBuiltinSuc' :: String -> TCM Term -> Expr -> TCM Term

- Agda.TypeChecking.Rules.Builtin: bindBuiltinType :: String -> Expr -> TCM ()

- Agda.TypeChecking.Rules.Builtin: bindBuiltinType1 :: String -> Expr -> TCM ()

- Agda.TypeChecking.Rules.Builtin: bindBuiltinZero' :: String -> TCM Term -> Expr -> TCM Term

- Agda.TypeChecking.Rules.Builtin: bindConstructor :: String -> (Expr -> TCM Term) -> Expr -> TCM ()

- Agda.TypeChecking.Rules.Builtin: bindPostulate :: String -> TCM Type -> Expr -> TCM ()

- Agda.TypeChecking.Rules.Builtin: builtinConstructors :: [(String, Expr -> TCM Term)]

- Agda.TypeChecking.Rules.Builtin: builtinDatatypes :: [(String, Int)]

- Agda.TypeChecking.Rules.Builtin: builtinPostulates :: [(String, TCM Type)]

- Agda.TypeChecking.Rules.Builtin: builtinPrimitives :: [(String, (String, Term -> TCM ()))]

- Agda.TypeChecking.Rules.Builtin: inductiveCheck :: String -> Term -> TCM ()

- Agda.TypeChecking.Rules.Builtin: typeOfSizeInf :: TCM Type

- Agda.TypeChecking.Rules.Builtin: typeOfSizeSuc :: TCM Type

- Agda.TypeChecking.Rules.Decl: checkDefinition :: Definition -> TCM ()

- Agda.TypeChecking.Rules.LHS.Unify: getSub :: Unify Sub

- Agda.TypeChecking.Rules.Term: checkTelescope :: Telescope -> Sort -> (Telescope -> TCM a) -> TCM a

- Agda.TypeChecking.Rules.Term: checkTypedBinding_ :: Hiding -> TypedBinding -> ([(String, Type)] -> TCM a) -> TCM a

- Agda.TypeChecking.Rules.Term: forcePi :: MonadTCM tcm => Hiding -> String -> Type -> tcm (Type, Constraints)

- Agda.TypeChecking.Serialise: instance [incoherent] EmbPrj Clauses

- Agda.TypeChecking.Substitute: data TelView

- Agda.TypeChecking.Substitute: instance Abstract Clauses

- Agda.TypeChecking.Substitute: instance Apply Clauses

- Agda.TypeChecking.Telescope: rename :: Subst t => Permutation -> t -> t

- Agda.TypeChecking.UniversePolymorphism: mlevel :: MonadTCM tcm => tcm (Maybe Term)

- Agda.TypeChecking.UniversePolymorphism: solveLevelConstraints :: TCM ()

- Agda.TypeChecking.UniversePolymorphism: warshallConstraint :: Constraint -> TCM [Constraint]

- Agda.TypeChecking.With: ArgPat :: Int -> ConPos -> ConPos

- Agda.TypeChecking.With: Here :: ConPos

- Agda.TypeChecking.With: constructorsInClause :: ConPos -> Clause -> [Range]

- Agda.TypeChecking.With: constructorsInClauses :: ConPos -> [Clause] -> [Range]

- Agda.TypeChecking.With: data ConPos

- Agda.TypeChecking.With: updateWithConstructorRanges :: [Telescope] -> [Arg Pattern] -> RHS -> [Arg Pattern]

+ Agda.Auto.Convert: fmLevel :: MetaId -> PlusLevel -> Bool

+ Agda.Auto.Convert: frommyType :: MExp O -> ErrorT String IO Type

+ Agda.Auto.SearchControl: costIotaStep, costIncrease, costAppExtraRef :: Int

+ Agda.Auto.SearchControl: prioNo, prioAbsurdLambda, prioNoIota, prioCompCopy, prioCompUnif, prioCompChoice, prioCompIota, prioCompareArgList, prioCompBetaStructured, prioCompBeta, prioInferredTypeUnknown, prioTypecheckArgList, prioTypeUnknown :: Int

+ Agda.Auto.Syntax: Instance :: FMode

+ Agda.Compiler.Epic.AuxAST: casee :: Expr -> [Branch] -> Expr

+ Agda.Compiler.Epic.AuxAST: funQName :: Fun -> Maybe QName

+ Agda.Compiler.Epic.AuxAST: getBrVars :: Branch -> [Var]

+ Agda.Compiler.Epic.AuxAST: lazy :: Expr -> Expr

+ Agda.Compiler.Epic.AuxAST: lett :: Var -> Expr -> Expr -> Expr

+ Agda.Compiler.Epic.AuxAST: substs :: [(Var, Var)] -> Expr -> Expr

+ Agda.Compiler.Epic.CaseOpts: caseOpts :: [Fun] -> Compile TCM [Fun]

+ Agda.Compiler.Epic.CaseOpts: caseOptsExpr :: Expr -> Compile TCM Expr

+ Agda.Compiler.Epic.CompileState: assignConstrTag :: QName -> Compile TCM Tag

+ Agda.Compiler.Epic.CompileState: assignConstrTag' :: QName -> [QName] -> Compile TCM Tag

+ Agda.Compiler.Epic.CompileState: bindExpr :: Expr -> (Var -> Compile TCM Expr) -> Compile TCM Expr

+ Agda.Compiler.Epic.CompileState: compiledModules :: CompileState -> Map TopLevelModuleName (EInterface, Set FilePath)

+ Agda.Compiler.Epic.CompileState: constrInScope :: QName -> Compile TCM Bool

+ Agda.Compiler.Epic.CompileState: curFun :: CompileState -> String

+ Agda.Compiler.Epic.CompileState: curModule :: CompileState -> EInterface

+ Agda.Compiler.Epic.CompileState: getConArity :: QName -> Compile TCM Int

+ Agda.Compiler.Epic.CompileState: getConData :: QName -> Compile TCM QName

+ Agda.Compiler.Epic.CompileState: getConstrTag' :: QName -> Compile TCM (Maybe Tag)

+ Agda.Compiler.Epic.CompileState: getDataCon :: QName -> Compile TCM [QName]

+ Agda.Compiler.Epic.CompileState: getForcedArgs :: QName -> Compile TCM ForcedArgs

+ Agda.Compiler.Epic.CompileState: getType :: QName -> Compile TCM Type

+ Agda.Compiler.Epic.CompileState: getsEI :: (EInterface -> a) -> Compile TCM a

+ Agda.Compiler.Epic.CompileState: importedModules :: CompileState -> EInterface

+ Agda.Compiler.Epic.CompileState: lookInterface :: (EInterface -> Maybe a) -> Compile TCM a -> Compile TCM a

+ Agda.Compiler.Epic.CompileState: modifyEI :: (EInterface -> EInterface) -> Compile TCM ()

+ Agda.Compiler.Epic.CompileState: putConArity :: QName -> Int -> Compile TCM ()

+ Agda.Compiler.Epic.CompileState: putConstrTag :: QName -> Tag -> Compile TCM ()

+ Agda.Compiler.Epic.CompileState: putForcedArgs :: QName -> ForcedArgs -> Compile TCM ()

+ Agda.Compiler.Epic.CompileState: resetNameSupply :: Compile TCM ()

+ Agda.Compiler.Epic.Epic: prettyEpic :: Expr -> String

+ Agda.Compiler.Epic.Erasure: (||-) :: Relevance -> Relevance -> Relevance

+ Agda.Compiler.Epic.Erasure: diff :: (Ord k, Eq a) => Map k a -> Map k a -> [(k, (a, a))]

+ Agda.Compiler.Epic.Erasure: ignoreForced :: Relevance -> Bool

+ Agda.Compiler.Epic.Erasure: initialRels :: Type -> Relevance -> [Relevance]

+ Agda.Compiler.Epic.Erasure: removeUnused :: Map Var [Relevance] -> Expr -> Expr

+ Agda.Compiler.Epic.ForceConstrs: forceConstrs :: [Fun] -> Compile TCM [Fun]

+ Agda.Compiler.Epic.ForceConstrs: forceFun :: Fun -> Compile TCM Fun

+ Agda.Compiler.Epic.ForceConstrs: makeForcedArgs :: Type -> ForcedArgs

+ Agda.Compiler.Epic.Forcing: buildTerm :: Var -> Nat -> Term -> Compile TCM (Expr -> Expr, Var)

+ Agda.Compiler.Epic.Forcing: dataParametersTCM :: QName -> TCM Nat

+ Agda.Compiler.Epic.Forcing: forcedExpr :: [Var] -> Telescope -> Expr -> Compile TCM Expr

+ Agda.Compiler.Epic.Forcing: piApplyM' :: Type -> Args -> TCM Type

+ Agda.Compiler.Epic.Injection: (!!!) :: Ord k => k :-> v -> k -> v

+ Agda.Compiler.Epic.Injection: (<:) :: Term -> Term -> (QName :-> InjectiveFun) -> Compile TCM InjConstraints

+ Agda.Compiler.Epic.Injection: IsTag :: Tag -> TagEq

+ Agda.Compiler.Epic.Injection: Same :: Int -> TagEq

+ Agda.Compiler.Epic.Injection: Tags :: Int :-> Set QName -> QName :-> TagEq -> Tags

+ Agda.Compiler.Epic.Injection: addConstraint :: QName -> QName -> InjConstraints -> InjConstraints

+ Agda.Compiler.Epic.Injection: constrGroup :: Tags -> QName :-> TagEq

+ Agda.Compiler.Epic.Injection: data TagEq

+ Agda.Compiler.Epic.Injection: data Tags

+ Agda.Compiler.Epic.Injection: emptyC :: InjConstraints

+ Agda.Compiler.Epic.Injection: eqGroups :: Tags -> Int :-> Set QName

+ Agda.Compiler.Epic.Injection: findInjection :: [(QName, Definition)] -> Compile TCM [(QName, Definition)]

+ Agda.Compiler.Epic.Injection: initialTags :: Map QName Tag -> [QName] -> Tags

+ Agda.Compiler.Epic.Injection: insertAt :: (Nat, Term) -> Term -> Term

+ Agda.Compiler.Epic.Injection: instance Eq TagEq

+ Agda.Compiler.Epic.Injection: isInjective :: QName -> [Clause] -> Compile TCM (Maybe ((QName, InjectiveFun), [(QName, QName)]))

+ Agda.Compiler.Epic.Injection: isInjectiveHere :: QName -> Int -> Clause -> Compile TCM InjConstraints

+ Agda.Compiler.Epic.Injection: isNoBody :: ClauseBody -> Bool

+ Agda.Compiler.Epic.Injection: litCon :: Literal -> Bool

+ Agda.Compiler.Epic.Injection: litToCon :: Literal -> TCM Term

+ Agda.Compiler.Epic.Injection: mergeGroups :: Int -> Int -> Tags -> Compile TCM (Maybe Tags)

+ Agda.Compiler.Epic.Injection: nrBinds :: Num i => Pattern -> i

+ Agda.Compiler.Epic.Injection: patternToTerm :: Nat -> Pattern -> Term

+ Agda.Compiler.Epic.Injection: remAbs :: ClauseBody -> Term

+ Agda.Compiler.Epic.Injection: replaceFunCC :: QName -> CompiledClauses -> Compile TCM ()

+ Agda.Compiler.Epic.Injection: setTag :: Int -> Tag -> Tags -> Compile TCM (Maybe Tags)

+ Agda.Compiler.Epic.Injection: solve :: [QName] -> [((QName, InjectiveFun), [(QName, QName)])] -> Compile TCM [(QName, InjectiveFun)]

+ Agda.Compiler.Epic.Injection: substForDot :: [Arg Pattern] -> Substitution

+ Agda.Compiler.Epic.Injection: type InjConstraints = Maybe [(QName, QName)]

+ Agda.Compiler.Epic.Injection: unifiable :: QName -> QName -> Compile TCM Bool

+ Agda.Compiler.Epic.Injection: unify :: QName -> QName -> Tags -> Compile TCM (Maybe Tags)

+ Agda.Compiler.Epic.Injection: unionConstraints :: [InjConstraints] -> InjConstraints

+ Agda.Compiler.Epic.Interface: EInterface :: Map QName Tag -> Set Var -> Map QName Bool -> Map QName Int -> Maybe QName -> Map Var RelevantArgs -> Map QName ForcedArgs -> Map QName InjectiveFun -> EInterface

+ Agda.Compiler.Epic.Interface: Forced :: Forced

+ Agda.Compiler.Epic.Interface: InjectiveFun :: Nat -> Nat -> InjectiveFun

+ Agda.Compiler.Epic.Interface: Irr :: Relevance

+ Agda.Compiler.Epic.Interface: NotForced :: Forced

+ Agda.Compiler.Epic.Interface: PrimTag :: Var -> Tag

+ Agda.Compiler.Epic.Interface: Rel :: Relevance

+ Agda.Compiler.Epic.Interface: Tag :: Int -> Tag

+ Agda.Compiler.Epic.Interface: conArity :: EInterface -> Map QName Int

+ Agda.Compiler.Epic.Interface: constrTags :: EInterface -> Map QName Tag

+ Agda.Compiler.Epic.Interface: data EInterface

+ Agda.Compiler.Epic.Interface: data Forced

+ Agda.Compiler.Epic.Interface: data InjectiveFun

+ Agda.Compiler.Epic.Interface: data Relevance

+ Agda.Compiler.Epic.Interface: data Tag

+ Agda.Compiler.Epic.Interface: defDelayed :: EInterface -> Map QName Bool

+ Agda.Compiler.Epic.Interface: definitions :: EInterface -> Set Var

+ Agda.Compiler.Epic.Interface: forced :: ForcedArgs -> [a] -> [a]

+ Agda.Compiler.Epic.Interface: forcedArgs :: EInterface -> Map QName ForcedArgs

+ Agda.Compiler.Epic.Interface: injArg :: InjectiveFun -> Nat

+ Agda.Compiler.Epic.Interface: injArity :: InjectiveFun -> Nat

+ Agda.Compiler.Epic.Interface: injectiveFuns :: EInterface -> Map QName InjectiveFun

+ Agda.Compiler.Epic.Interface: instance Eq Forced

+ Agda.Compiler.Epic.Interface: instance Eq InjectiveFun

+ Agda.Compiler.Epic.Interface: instance Eq Relevance

+ Agda.Compiler.Epic.Interface: instance Eq Tag

+ Agda.Compiler.Epic.Interface: instance Monoid EInterface

+ Agda.Compiler.Epic.Interface: instance Ord Relevance

+ Agda.Compiler.Epic.Interface: instance Ord Tag

+ Agda.Compiler.Epic.Interface: instance Show EInterface

+ Agda.Compiler.Epic.Interface: instance Show Forced

+ Agda.Compiler.Epic.Interface: instance Show InjectiveFun

+ Agda.Compiler.Epic.Interface: instance Show Relevance

+ Agda.Compiler.Epic.Interface: instance Show Tag

+ Agda.Compiler.Epic.Interface: instance Typeable EInterface

+ Agda.Compiler.Epic.Interface: instance Typeable Forced

+ Agda.Compiler.Epic.Interface: instance Typeable InjectiveFun

+ Agda.Compiler.Epic.Interface: instance Typeable Relevance

+ Agda.Compiler.Epic.Interface: instance Typeable Tag

+ Agda.Compiler.Epic.Interface: mainName :: EInterface -> Maybe QName

+ Agda.Compiler.Epic.Interface: notForced :: ForcedArgs -> [a] -> [a]

+ Agda.Compiler.Epic.Interface: pairwiseFilter :: [Bool] -> [a] -> [a]

+ Agda.Compiler.Epic.Interface: relevantArgs :: EInterface -> Map Var RelevantArgs

+ Agda.Compiler.Epic.Interface: type ForcedArgs = [Forced]

+ Agda.Compiler.Epic.Interface: type RelevantArgs = [Relevance]

+ Agda.Compiler.Epic.Interface: type Var = String

+ Agda.Compiler.Epic.NatDetection: isNatish :: QName -> Defn -> Compile TCM (Maybe (ForcedArgs, [QName]))

+ Agda.Compiler.Epic.Primitive: initialPrims :: Compile TCM ()

+ Agda.Compiler.Epic.Primitive: prZero, prNatEquality, prPred, prFalse, prTrue, prSuc :: Var

+ Agda.Compiler.Epic.Smashing: (+++) :: Telescope -> Telescope -> Telescope

+ Agda.Compiler.Epic.Smashing: buildLambda :: (Ord n, Num n) => n -> Expr -> Expr

+ Agda.Compiler.Epic.Smashing: defnPars :: Integral n => Defn -> n

+ Agda.Compiler.Epic.Smashing: inferable :: Set QName -> QName -> [Arg Term] -> Compile TCM (Maybe Expr)

+ Agda.Compiler.Epic.Smashing: smash'em :: [Fun] -> Compile TCM [Fun]

+ Agda.Compiler.Epic.Smashing: smashable :: Int -> Type -> Compile TCM (Maybe Expr)

+ Agda.Compiler.Epic.Static: etaExpand :: Term -> Compile TCM Term

+ Agda.Compiler.Epic.Static: evaluateCC :: CompiledClauses -> Compile TCM CompiledClauses

+ Agda.Compiler.Epic.Static: evaluateTerm :: Term -> Compile TCM Term

+ Agda.Compiler.Epic.Static: normaliseStatic :: CompiledClauses -> Compile TCM CompiledClauses

+ Agda.Compiler.HaskellTypes: hsUnit :: HaskellType

+ Agda.Compiler.JS.Case: Case :: [Patt] -> Exp -> Case

+ Agda.Compiler.JS.Case: Tag :: MemberId -> [MemberId] -> (Exp -> [Exp] -> Exp) -> Tag

+ Agda.Compiler.JS.Case: Tagged :: Tag -> [Patt] -> Patt

+ Agda.Compiler.JS.Case: VarPatt :: Patt

+ Agda.Compiler.JS.Case: body :: Case -> Exp

+ Agda.Compiler.JS.Case: data Case

+ Agda.Compiler.JS.Case: data Patt

+ Agda.Compiler.JS.Case: data Tag

+ Agda.Compiler.JS.Case: instance Pretty Case

+ Agda.Compiler.JS.Case: instance Pretty Patt

+ Agda.Compiler.JS.Case: instance Show Case

+ Agda.Compiler.JS.Case: instance Show Patt

+ Agda.Compiler.JS.Case: instance Show Tag

+ Agda.Compiler.JS.Case: lambda :: [Case] -> Exp

+ Agda.Compiler.JS.Case: lambda' :: Nat -> Nat -> Nat -> [Case] -> Exp

+ Agda.Compiler.JS.Case: match :: Nat -> Nat -> Nat -> [Case] -> MemberId -> Nat -> Exp

+ Agda.Compiler.JS.Case: numVars :: [Patt] -> Nat

+ Agda.Compiler.JS.Case: numVars' :: Patt -> Nat

+ Agda.Compiler.JS.Case: pats :: Case -> [Patt]

+ Agda.Compiler.JS.Case: pop :: Case -> Case

+ Agda.Compiler.JS.Case: refine :: MemberId -> Nat -> Case -> [Case]

+ Agda.Compiler.JS.Case: tag :: Case -> Map MemberId Nat

+ Agda.Compiler.JS.Case: tags :: [Case] -> Map MemberId Nat

+ Agda.Compiler.JS.Case: visit :: [Case] -> Exp -> [Exp] -> Exp

+ Agda.Compiler.JS.Compiler: args :: Maybe (QName, Int) -> Args -> TCM [Exp]

+ Agda.Compiler.JS.Compiler: body :: ClauseBody -> TCM Exp

+ Agda.Compiler.JS.Compiler: clause :: Clause -> TCM Case

+ Agda.Compiler.JS.Compiler: compile :: Interface -> TCM ()

+ Agda.Compiler.JS.Compiler: compileDir :: TCM FilePath

+ Agda.Compiler.JS.Compiler: compilerMain :: Interface -> TCM ()

+ Agda.Compiler.JS.Compiler: curModule :: TCM Module

+ Agda.Compiler.JS.Compiler: defProjection :: Definition -> Maybe (QName, Int)

+ Agda.Compiler.JS.Compiler: definition :: (QName, Definition) -> TCM Export

+ Agda.Compiler.JS.Compiler: defn :: QName -> [MemberId] -> Type -> Maybe JSCode -> Defn -> TCM Exp

+ Agda.Compiler.JS.Compiler: dummyLambda :: Int -> Exp -> Exp

+ Agda.Compiler.JS.Compiler: global :: QName -> TCM (Exp, [MemberId])

+ Agda.Compiler.JS.Compiler: global' :: QName -> TCM (Exp, [MemberId])

+ Agda.Compiler.JS.Compiler: insertAfter :: Set [MemberId] -> Export -> [Export] -> [Export]

+ Agda.Compiler.JS.Compiler: isSingleton :: Type -> TCM (Maybe Exp)

+ Agda.Compiler.JS.Compiler: jsFileName :: GlobalId -> String

+ Agda.Compiler.JS.Compiler: jsMember :: Name -> MemberId

+ Agda.Compiler.JS.Compiler: jsMod :: ModuleName -> GlobalId

+ Agda.Compiler.JS.Compiler: literal :: Literal -> Exp

+ Agda.Compiler.JS.Compiler: mapping :: [Pattern] -> (Nat, Nat, [Exp])

+ Agda.Compiler.JS.Compiler: mapping' :: Pattern -> (Nat, Nat, [Exp]) -> (Nat, Nat, [Exp])

+ Agda.Compiler.JS.Compiler: numPars :: [Clause] -> Nat

+ Agda.Compiler.JS.Compiler: outFile :: GlobalId -> TCM FilePath

+ Agda.Compiler.JS.Compiler: outFile_ :: TCM FilePath

+ Agda.Compiler.JS.Compiler: pattern :: Pattern -> TCM Patt

+ Agda.Compiler.JS.Compiler: qname :: QName -> TCM Exp

+ Agda.Compiler.JS.Compiler: reorder :: [Export] -> [Export]

+ Agda.Compiler.JS.Compiler: reorder' :: Set [MemberId] -> [Export] -> [Export]

+ Agda.Compiler.JS.Compiler: tag :: QName -> TCM Tag

+ Agda.Compiler.JS.Compiler: term :: Term -> TCM Exp

+ Agda.Compiler.JS.Compiler: visitorName :: QName -> TCM MemberId

+ Agda.Compiler.JS.Compiler: writeModule :: Module -> TCM ()

+ Agda.Compiler.JS.Parser: binop :: Parser String

+ Agda.Compiler.JS.Parser: braced :: Parser a -> Parser a

+ Agda.Compiler.JS.Parser: bracedBlock :: (Map String Nat) -> Parser Exp

+ Agda.Compiler.JS.Parser: bracketed :: Parser a -> Parser a

+ Agda.Compiler.JS.Parser: escChr :: Parser Char

+ Agda.Compiler.JS.Parser: exp :: (Map String Nat) -> Parser Exp

+ Agda.Compiler.JS.Parser: exp0 :: (Map String Nat) -> Parser Exp

+ Agda.Compiler.JS.Parser: exp1 :: (Map String Nat) -> Parser Exp

+ Agda.Compiler.JS.Parser: exp2 :: (Map String Nat) -> Parser Exp

+ Agda.Compiler.JS.Parser: exp2' :: (Map String Nat) -> Exp -> Parser Exp

+ Agda.Compiler.JS.Parser: exp3 :: (Map String Nat) -> Parser Exp

+ Agda.Compiler.JS.Parser: exp3' :: (Map String Nat) -> Exp -> Parser Exp

+ Agda.Compiler.JS.Parser: field :: (Map String Nat) -> Parser (MemberId, Exp)

+ Agda.Compiler.JS.Parser: function :: (Map String Nat) -> Parser Exp

+ Agda.Compiler.JS.Parser: globalid :: Parser Exp

+ Agda.Compiler.JS.Parser: identifier :: Parser String

+ Agda.Compiler.JS.Parser: ifBlock :: (Map String Nat) -> Parser Exp

+ Agda.Compiler.JS.Parser: intLit :: Parser Exp

+ Agda.Compiler.JS.Parser: localid :: (Map String Nat) -> Parser Exp

+ Agda.Compiler.JS.Parser: object :: (Map String Nat) -> Parser Exp

+ Agda.Compiler.JS.Parser: parened :: Parser a -> Parser a

+ Agda.Compiler.JS.Parser: parse :: String -> Either Exp String

+ Agda.Compiler.JS.Parser: preop :: Parser String

+ Agda.Compiler.JS.Parser: punct :: Char -> Parser ()

+ Agda.Compiler.JS.Parser: quoted :: Parser a -> Parser a

+ Agda.Compiler.JS.Parser: returnBlock :: (Map String Nat) -> Parser Exp

+ Agda.Compiler.JS.Parser: stringChr :: Parser Char

+ Agda.Compiler.JS.Parser: stringLit :: Parser Exp

+ Agda.Compiler.JS.Parser: stringStr :: Parser String

+ Agda.Compiler.JS.Parser: token :: String -> Parser ()

+ Agda.Compiler.JS.Parser: topLevel :: Parser Exp

+ Agda.Compiler.JS.Parser: type Parser = ReadP Char

+ Agda.Compiler.JS.Parser: undef :: Parser Exp

+ Agda.Compiler.JS.Parser: wordBoundary :: Parser ()

+ Agda.Compiler.JS.Pretty: block :: Nat -> Int -> Exp -> String

+ Agda.Compiler.JS.Pretty: block' :: Nat -> Int -> Exp -> String

+ Agda.Compiler.JS.Pretty: br :: Int -> String

+ Agda.Compiler.JS.Pretty: class Pretties a

+ Agda.Compiler.JS.Pretty: class Pretty a

+ Agda.Compiler.JS.Pretty: exports :: Nat -> Int -> Set [MemberId] -> [Export] -> String

+ Agda.Compiler.JS.Pretty: instance (Pretty a, Pretty b) => Pretties (Map a b)

+ Agda.Compiler.JS.Pretty: instance (Pretty a, Pretty b) => Pretty (a, b)

+ Agda.Compiler.JS.Pretty: instance Pretty Exp

+ Agda.Compiler.JS.Pretty: instance Pretty GlobalId

+ Agda.Compiler.JS.Pretty: instance Pretty LocalId

+ Agda.Compiler.JS.Pretty: instance Pretty MemberId

+ Agda.Compiler.JS.Pretty: instance Pretty Module

+ Agda.Compiler.JS.Pretty: instance Pretty a => Pretties [a]

+ Agda.Compiler.JS.Pretty: modname :: GlobalId -> String

+ Agda.Compiler.JS.Pretty: pretties :: Pretties a => Nat -> Int -> a -> [String]

+ Agda.Compiler.JS.Pretty: pretty :: Pretty a => Nat -> Int -> a -> String

+ Agda.Compiler.JS.Pretty: unescape :: Char -> String

+ Agda.Compiler.JS.Pretty: unescapes :: String -> String

+ Agda.Compiler.JS.Substitution: apply :: Exp -> [Exp] -> Exp

+ Agda.Compiler.JS.Substitution: curriedApply :: Exp -> [Exp] -> Exp

+ Agda.Compiler.JS.Substitution: curriedLambda :: Nat -> Exp -> Exp

+ Agda.Compiler.JS.Substitution: emp :: Exp

+ Agda.Compiler.JS.Substitution: fix :: Exp -> Exp

+ Agda.Compiler.JS.Substitution: lookup :: Exp -> MemberId -> Exp

+ Agda.Compiler.JS.Substitution: map :: Nat -> (Nat -> LocalId -> Exp) -> Exp -> Exp

+ Agda.Compiler.JS.Substitution: map' :: Nat -> (Nat -> LocalId -> Exp) -> Exp -> Exp

+ Agda.Compiler.JS.Substitution: object :: [([MemberId], Exp)] -> Exp

+ Agda.Compiler.JS.Substitution: self :: Exp -> Exp -> Exp

+ Agda.Compiler.JS.Substitution: shift :: Nat -> Exp -> Exp

+ Agda.Compiler.JS.Substitution: shiftFrom :: Nat -> Nat -> Exp -> Exp

+ Agda.Compiler.JS.Substitution: shifter :: Nat -> Nat -> LocalId -> Exp

+ Agda.Compiler.JS.Substitution: subst :: Nat -> [Exp] -> Exp -> Exp

+ Agda.Compiler.JS.Substitution: subst' :: Nat -> [Exp] -> Exp -> Exp

+ Agda.Compiler.JS.Substitution: substituter :: Nat -> [Exp] -> Nat -> LocalId -> Exp

+ Agda.Compiler.JS.Substitution: union :: Exp -> Exp -> Exp

+ Agda.Compiler.JS.Substitution: vine :: [MemberId] -> Exp -> Exp

+ Agda.Compiler.JS.Syntax: Apply :: Exp -> [Exp] -> Exp

+ Agda.Compiler.JS.Syntax: BinOp :: Exp -> String -> Exp -> Exp

+ Agda.Compiler.JS.Syntax: Char :: Char -> Exp

+ Agda.Compiler.JS.Syntax: Const :: String -> Exp

+ Agda.Compiler.JS.Syntax: Double :: Double -> Exp

+ Agda.Compiler.JS.Syntax: Export :: [MemberId] -> Exp -> Export

+ Agda.Compiler.JS.Syntax: Global :: GlobalId -> Exp

+ Agda.Compiler.JS.Syntax: GlobalId :: [String] -> GlobalId

+ Agda.Compiler.JS.Syntax: If :: Exp -> Exp -> Exp -> Exp

+ Agda.Compiler.JS.Syntax: Integer :: Integer -> Exp

+ Agda.Compiler.JS.Syntax: Lambda :: Nat -> Exp -> Exp

+ Agda.Compiler.JS.Syntax: Local :: LocalId -> Exp

+ Agda.Compiler.JS.Syntax: LocalId :: Nat -> LocalId

+ Agda.Compiler.JS.Syntax: Lookup :: Exp -> MemberId -> Exp

+ Agda.Compiler.JS.Syntax: MemberId :: String -> MemberId

+ Agda.Compiler.JS.Syntax: Module :: GlobalId -> [Export] -> Module

+ Agda.Compiler.JS.Syntax: Object :: (Map MemberId Exp) -> Exp

+ Agda.Compiler.JS.Syntax: PreOp :: String -> Exp -> Exp

+ Agda.Compiler.JS.Syntax: Self :: Exp

+ Agda.Compiler.JS.Syntax: String :: String -> Exp

+ Agda.Compiler.JS.Syntax: Undefined :: Exp

+ Agda.Compiler.JS.Syntax: class Globals a

+ Agda.Compiler.JS.Syntax: class Uses a

+ Agda.Compiler.JS.Syntax: data Exp

+ Agda.Compiler.JS.Syntax: data Export

+ Agda.Compiler.JS.Syntax: data Module

+ Agda.Compiler.JS.Syntax: defn :: Export -> Exp

+ Agda.Compiler.JS.Syntax: expName :: Export -> [MemberId]

+ Agda.Compiler.JS.Syntax: exports :: Module -> [Export]

+ Agda.Compiler.JS.Syntax: globals :: Globals a => a -> Set GlobalId

+ Agda.Compiler.JS.Syntax: instance Data Exp

+ Agda.Compiler.JS.Syntax: instance Data Export

+ Agda.Compiler.JS.Syntax: instance Data GlobalId

+ Agda.Compiler.JS.Syntax: instance Data LocalId

+ Agda.Compiler.JS.Syntax: instance Data MemberId

+ Agda.Compiler.JS.Syntax: instance Data Module

+ Agda.Compiler.JS.Syntax: instance Eq GlobalId

+ Agda.Compiler.JS.Syntax: instance Eq LocalId

+ Agda.Compiler.JS.Syntax: instance Eq MemberId

+ Agda.Compiler.JS.Syntax: instance Globals Exp

+ Agda.Compiler.JS.Syntax: instance Globals Export

+ Agda.Compiler.JS.Syntax: instance Globals Module

+ Agda.Compiler.JS.Syntax: instance Globals a => Globals (Map k a)

+ Agda.Compiler.JS.Syntax: instance Globals a => Globals [a]

+ Agda.Compiler.JS.Syntax: instance Ord GlobalId

+ Agda.Compiler.JS.Syntax: instance Ord LocalId

+ Agda.Compiler.JS.Syntax: instance Ord MemberId

+ Agda.Compiler.JS.Syntax: instance Show Exp

+ Agda.Compiler.JS.Syntax: instance Show Export

+ Agda.Compiler.JS.Syntax: instance Show GlobalId

+ Agda.Compiler.JS.Syntax: instance Show LocalId

+ Agda.Compiler.JS.Syntax: instance Show MemberId

+ Agda.Compiler.JS.Syntax: instance Show Module

+ Agda.Compiler.JS.Syntax: instance Typeable Exp

+ Agda.Compiler.JS.Syntax: instance Typeable Export

+ Agda.Compiler.JS.Syntax: instance Typeable GlobalId

+ Agda.Compiler.JS.Syntax: instance Typeable LocalId

+ Agda.Compiler.JS.Syntax: instance Typeable MemberId

+ Agda.Compiler.JS.Syntax: instance Typeable Module

+ Agda.Compiler.JS.Syntax: instance Uses Exp

+ Agda.Compiler.JS.Syntax: instance Uses Export

+ Agda.Compiler.JS.Syntax: instance Uses a => Uses (Map k a)

+ Agda.Compiler.JS.Syntax: instance Uses a => Uses [a]

+ Agda.Compiler.JS.Syntax: modName :: Module -> GlobalId

+ Agda.Compiler.JS.Syntax: newtype GlobalId

+ Agda.Compiler.JS.Syntax: newtype LocalId

+ Agda.Compiler.JS.Syntax: newtype MemberId

+ Agda.Compiler.JS.Syntax: uses :: Uses a => a -> Set [MemberId]

+ Agda.Compiler.MAlonzo.Compiler: conArityAndPars :: QName -> TCM (Nat, Nat)

+ Agda.Compiler.MAlonzo.Compiler: litqname :: QName -> TCM Exp

+ Agda.Compiler.MAlonzo.Misc: rtmIncompleteMatch :: QName -> Exp

+ Agda.Interaction.BasicOps: CmpElim :: [Polarity] -> a -> [b] -> [b] -> OutputConstraint a b

+ Agda.Interaction.BasicOps: FindInScopeOF :: b -> OutputConstraint a b

+ Agda.Interaction.BasicOps: OutputForm :: ProblemId -> (OutputConstraint a b) -> OutputForm a b

+ Agda.Interaction.BasicOps: data OutputConstraint a b

+ Agda.Interaction.BasicOps: data OutputConstraint' a b

+ Agda.Interaction.BasicOps: instance (Pretty a, Pretty b) => Pretty (OutputConstraint' a b)

+ Agda.Interaction.BasicOps: instance (Show a, Show b) => Show (OutputConstraint a b)

+ Agda.Interaction.BasicOps: instance (ToConcrete a c, ToConcrete b d) => ToConcrete (OutputConstraint a b) (OutputConstraint c d)

+ Agda.Interaction.BasicOps: instance (ToConcrete a c, ToConcrete b d) => ToConcrete (OutputConstraint' a b) (OutputConstraint' c d)

+ Agda.Interaction.BasicOps: instance Functor (OutputConstraint a)

+ Agda.Interaction.BasicOps: instance Reify Constraint (OutputConstraint Expr Expr)

+ Agda.Interaction.BasicOps: instance Reify ProblemConstraint (Closure (OutputForm Expr Expr))

+ Agda.Interaction.EmacsCommand: A :: a -> Lisp a

+ Agda.Interaction.EmacsCommand: Cons :: (Lisp a) -> (Lisp a) -> Lisp a

+ Agda.Interaction.EmacsCommand: L :: [Lisp a] -> Lisp a

+ Agda.Interaction.EmacsCommand: Q :: (Lisp a) -> Lisp a

+ Agda.Interaction.EmacsCommand: data Lisp a

+ Agda.Interaction.EmacsCommand: instance Pretty String

+ Agda.Interaction.EmacsCommand: instance Pretty a => Pretty (Lisp a)

+ Agda.Interaction.EmacsCommand: instance Pretty a => Show (Lisp a)

+ Agda.Interaction.EmacsCommand: putResponse :: Lisp String -> IO ()

+ Agda.Interaction.GhciTop: JS :: Backend

+ Agda.Interaction.GhciTop: instance LowerMeta (Maybe Expr)

+ Agda.Interaction.GhciTop: instance LowerMeta (OpApp Expr)

+ Agda.Interaction.GhciTop: instance LowerMeta ModuleApplication

+ Agda.Interaction.Highlighting.Dot: DotState :: Map ModuleName String -> [String] -> Set (String, String) -> DotState

+ Agda.Interaction.Highlighting.Dot: addConnection :: String -> String -> DotM ()

+ Agda.Interaction.Highlighting.Dot: addModule :: ModuleName -> DotM (String, Bool)

+ Agda.Interaction.Highlighting.Dot: data DotState

+ Agda.Interaction.Highlighting.Dot: dottify :: Interface -> DotM String

+ Agda.Interaction.Highlighting.Dot: dsConnection :: DotState -> Set (String, String)

+ Agda.Interaction.Highlighting.Dot: dsModules :: DotState -> Map ModuleName String

+ Agda.Interaction.Highlighting.Dot: dsNameSupply :: DotState -> [String]

+ Agda.Interaction.Highlighting.Dot: generateDot :: Interface -> TCM ()

+ Agda.Interaction.Highlighting.Dot: initialDotState :: DotState

+ Agda.Interaction.Highlighting.Dot: type DotM = StateT DotState TCM

+ Agda.Interaction.MakeCase: ExtendedLambda :: Int -> Int -> CaseContext

+ Agda.Interaction.MakeCase: FunctionDef :: CaseContext

+ Agda.Interaction.MakeCase: data CaseContext

+ Agda.Interaction.MakeCase: instance Eq CaseContext

+ Agda.Interaction.Options: optDependencyGraph :: CommandLineOptions -> Maybe FilePath

+ Agda.Interaction.Options: optExperimentalIrrelevance :: PragmaOptions -> Bool

+ Agda.Interaction.Options: optJSCompile :: CommandLineOptions -> Bool

+ Agda.Interaction.Options: optSafe :: CommandLineOptions -> Bool

+ Agda.Interaction.Options: unsafePragmaOptions :: PragmaOptions -> [String]

+ Agda.Syntax.Abstract: CompiledJSPragma :: QName -> String -> Pragma

+ Agda.Syntax.Abstract: DataSig :: DefInfo -> QName -> Telescope -> Expr -> Declaration

+ Agda.Syntax.Abstract: ExtendedLam :: ExprInfo -> DefInfo -> QName -> [Clause] -> Expr

+ Agda.Syntax.Abstract: Mutual :: DeclInfo -> [Declaration] -> Declaration

+ Agda.Syntax.Abstract: QuoteTerm :: ExprInfo -> Expr

+ Agda.Syntax.Abstract: RecSig :: DefInfo -> QName -> Telescope -> Expr -> Declaration

+ Agda.Syntax.Abstract: RecUpdate :: ExprInfo -> Expr -> [(Name, Expr)] -> Expr

+ Agda.Syntax.Abstract: RecordModuleIFS :: ModuleName -> ModuleApplication

+ Agda.Syntax.Abstract: SectionApp :: [TypedBindings] -> ModuleName -> [NamedArg Expr] -> ModuleApplication

+ Agda.Syntax.Abstract: StaticPragma :: QName -> Pragma

+ Agda.Syntax.Abstract: Unquote :: ExprInfo -> Expr

+ Agda.Syntax.Abstract: anyAbstract :: AnyAbstract a => a -> Bool

+ Agda.Syntax.Abstract: class AnyAbstract a

+ Agda.Syntax.Abstract: class GetDefInfo a

+ Agda.Syntax.Abstract: data ModuleApplication

+ Agda.Syntax.Abstract: getDefInfo :: GetDefInfo a => a -> Maybe DefInfo

+ Agda.Syntax.Abstract: instance AnyAbstract Declaration

+ Agda.Syntax.Abstract: instance AnyAbstract a => AnyAbstract [a]

+ Agda.Syntax.Abstract: instance Data ModuleApplication

+ Agda.Syntax.Abstract: instance GetDefInfo Declaration

+ Agda.Syntax.Abstract: instance KillRange ModuleApplication

+ Agda.Syntax.Abstract: instance KillRange x => KillRange (ThingWithFixity x)

+ Agda.Syntax.Abstract: instance Show ModuleApplication

+ Agda.Syntax.Abstract: instance Typeable ModuleApplication

+ Agda.Syntax.Abstract.Name: mnameToQName :: ModuleName -> QName

+ Agda.Syntax.Common: Instance :: Hiding

+ Agda.Syntax.Common: NonStrict :: Relevance

+ Agda.Syntax.Common: OnlyQualified :: Access

+ Agda.Syntax.Common: makeInstance :: Arg a -> Arg a

+ Agda.Syntax.Common: moreRelevant :: Relevance -> Relevance -> Bool

+ Agda.Syntax.Concrete: CompiledJSPragma :: !Range -> QName -> String -> Pragma

+ Agda.Syntax.Concrete: DataSig :: !Range -> Induction -> Name -> [LamBinding] -> Expr -> Declaration

+ Agda.Syntax.Concrete: DontCare :: Expr -> Expr

+ Agda.Syntax.Concrete: ExtendedLam :: !Range -> [(LHS, RHS, WhereClause)] -> Expr

+ Agda.Syntax.Concrete: InstanceArg :: !Range -> (Named String Expr) -> Expr

+ Agda.Syntax.Concrete: InstanceP :: !Range -> (Named String Pattern) -> Pattern

+ Agda.Syntax.Concrete: Ordinary :: e -> OpApp e

+ Agda.Syntax.Concrete: QuoteTerm :: !Range -> Expr

+ Agda.Syntax.Concrete: RecUpdate :: !Range -> Expr -> [(Name, Expr)] -> Expr

+ Agda.Syntax.Concrete: RecordModuleIFS :: Range -> QName -> ModuleApplication

+ Agda.Syntax.Concrete: RecordSig :: !Range -> Name -> [LamBinding] -> Expr -> Declaration

+ Agda.Syntax.Concrete: SectionApp :: Range -> [TypedBindings] -> Expr -> ModuleApplication

+ Agda.Syntax.Concrete: StaticPragma :: !Range -> QName -> Pragma

+ Agda.Syntax.Concrete: SyntaxBindingLambda :: !Range -> [LamBinding] -> e -> OpApp e

+ Agda.Syntax.Concrete: ThingWithFixity :: x -> Fixity' -> ThingWithFixity x

+ Agda.Syntax.Concrete: Unquote :: !Range -> Expr

+ Agda.Syntax.Concrete: data ModuleApplication

+ Agda.Syntax.Concrete: data OpApp e

+ Agda.Syntax.Concrete: data ThingWithFixity x

+ Agda.Syntax.Concrete: fromOrdinary :: e -> OpApp e -> e

+ Agda.Syntax.Concrete: instance Data ModuleApplication

+ Agda.Syntax.Concrete: instance Data e => Data (OpApp e)

+ Agda.Syntax.Concrete: instance Functor OpApp

+ Agda.Syntax.Concrete: instance HasRange ModuleApplication

+ Agda.Syntax.Concrete: instance HasRange e => HasRange (OpApp e)

+ Agda.Syntax.Concrete: instance Show AsName

+ Agda.Syntax.Concrete: instance Typeable ModuleApplication

+ Agda.Syntax.Concrete: instance Typeable1 OpApp

+ Agda.Syntax.Concrete: lhsOriginalPattern :: LHS -> Pattern

+ Agda.Syntax.Concrete: lhsRewriteEqn :: LHS -> [RewriteEqn]

+ Agda.Syntax.Concrete: lhsWithExpr :: LHS -> [WithExpr]

+ Agda.Syntax.Concrete: lhsWithPattern :: LHS -> [Pattern]

+ Agda.Syntax.Concrete: patternHead :: Pattern -> Maybe Name

+ Agda.Syntax.Concrete: patternNames :: Pattern -> [Name]

+ Agda.Syntax.Concrete.Definitions: AmbiguousFunClauses :: LHS -> [Name] -> DeclarationException

+ Agda.Syntax.Concrete.Definitions: FunSig :: Range -> Fixity' -> Access -> Relevance -> Name -> Expr -> NiceDeclaration

+ Agda.Syntax.Concrete.Definitions: MissingDataSignature :: Name -> DeclarationException

+ Agda.Syntax.Concrete.Definitions: NiceDataSig :: Range -> Fixity' -> Access -> Name -> [LamBinding] -> Expr -> NiceDeclaration

+ Agda.Syntax.Concrete.Definitions: NiceMutual :: Range -> [NiceDeclaration] -> NiceDeclaration

+ Agda.Syntax.Concrete.Definitions: NiceRecSig :: Range -> Fixity' -> Access -> Name -> [LamBinding] -> Expr -> NiceDeclaration

+ Agda.Syntax.Concrete.Definitions: UselessAbstract :: Range -> DeclarationException

+ Agda.Syntax.Concrete.Definitions: UselessPrivate :: Range -> DeclarationException

+ Agda.Syntax.Concrete.Definitions: instance Eq DataRecOrFun

+ Agda.Syntax.Concrete.Definitions: instance Eq InMutual

+ Agda.Syntax.Concrete.Definitions: instance Ord DataRecOrFun

+ Agda.Syntax.Concrete.Definitions: instance Show Clause

+ Agda.Syntax.Concrete.Definitions: instance Show InMutual

+ Agda.Syntax.Concrete.Definitions: instance Show NiceDeclaration

+ Agda.Syntax.Concrete.Name: isPrefix, isNonfix, isInfix, isPostfix :: Name -> Bool

+ Agda.Syntax.Concrete.Name: nameStringParts :: Name -> [String]

+ Agda.Syntax.Concrete.Operators.Parser: InstanceArgV :: (Named String e) -> ExprView e

+ Agda.Syntax.Concrete.Operators.Parser: WildV :: e -> ExprView e

+ Agda.Syntax.Concrete.Operators.Parser: infixP, nonfixP, prefixP, postfixP, infixlP, infixrP :: IsExpr e => ReadP e (NewNotation, Range, [e]) -> ReadP e e -> ReadP e e

+ Agda.Syntax.Concrete.Operators.Parser: preop, postop :: IsExpr e => ReadP e (NewNotation, Range, [e]) -> ReadP e (e -> ReadP a e)

+ Agda.Syntax.Concrete.Pretty: dbraces :: Doc -> Doc

+ Agda.Syntax.Concrete.Pretty: instance Pretty (OpApp Expr)

+ Agda.Syntax.Concrete.Pretty: instance Pretty (ThingWithFixity Name)

+ Agda.Syntax.Concrete.Pretty: instance Pretty ModuleApplication

+ Agda.Syntax.Concrete.Pretty: instance Show LHS

+ Agda.Syntax.Concrete.Pretty: instance Show ModuleApplication

+ Agda.Syntax.Concrete.Pretty: instance Show WhereClause

+ Agda.Syntax.Fixity: ThingWithFixity :: x -> Fixity' -> ThingWithFixity x

+ Agda.Syntax.Fixity: data ThingWithFixity x

+ Agda.Syntax.Fixity: instance Data x => Data (ThingWithFixity x)

+ Agda.Syntax.Fixity: instance Foldable ThingWithFixity

+ Agda.Syntax.Fixity: instance Functor ThingWithFixity

+ Agda.Syntax.Fixity: instance Show x => Show (ThingWithFixity x)

+ Agda.Syntax.Fixity: instance Traversable ThingWithFixity

+ Agda.Syntax.Fixity: instance Typeable1 ThingWithFixity

+ Agda.Syntax.Internal: Apply :: (Arg Term) -> Elim

+ Agda.Syntax.Internal: BlockedLevel :: MetaId -> Term -> LevelAtom

+ Agda.Syntax.Internal: ClosedLevel :: Integer -> PlusLevel

+ Agda.Syntax.Internal: Level :: Level -> Term

+ Agda.Syntax.Internal: Max :: [PlusLevel] -> Level

+ Agda.Syntax.Internal: MetaLevel :: MetaId -> Args -> LevelAtom

+ Agda.Syntax.Internal: NeutralLevel :: Term -> LevelAtom

+ Agda.Syntax.Internal: NoAbs :: String -> a -> Abs a

+ Agda.Syntax.Internal: Plus :: Integer -> LevelAtom -> PlusLevel

+ Agda.Syntax.Internal: Proj :: QName -> Elim

+ Agda.Syntax.Internal: UnreducedLevel :: Term -> LevelAtom

+ Agda.Syntax.Internal: data Elim

+ Agda.Syntax.Internal: data LevelAtom

+ Agda.Syntax.Internal: data PlusLevel

+ Agda.Syntax.Internal: instance Data Level

+ Agda.Syntax.Internal: instance Data LevelAtom

+ Agda.Syntax.Internal: instance Data PlusLevel

+ Agda.Syntax.Internal: instance Foldable Tele

+ Agda.Syntax.Internal: instance KillRange Level

+ Agda.Syntax.Internal: instance KillRange LevelAtom

+ Agda.Syntax.Internal: instance KillRange PlusLevel

+ Agda.Syntax.Internal: instance Show Elim

+ Agda.Syntax.Internal: instance Show Level

+ Agda.Syntax.Internal: instance Show LevelAtom

+ Agda.Syntax.Internal: instance Show PlusLevel

+ Agda.Syntax.Internal: instance Sized Level

+ Agda.Syntax.Internal: instance Sized LevelAtom

+ Agda.Syntax.Internal: instance Sized PlusLevel

+ Agda.Syntax.Internal: instance Traversable Tele

+ Agda.Syntax.Internal: instance Typeable Level

+ Agda.Syntax.Internal: instance Typeable LevelAtom

+ Agda.Syntax.Internal: instance Typeable PlusLevel

+ Agda.Syntax.Internal: newtype Level

+ Agda.Syntax.Internal: topSort :: Type

+ Agda.Syntax.Internal: unAbs :: Abs a -> a

+ Agda.Syntax.Internal.Generic: instance TermLike Level

+ Agda.Syntax.Internal.Generic: instance TermLike LevelAtom

+ Agda.Syntax.Internal.Generic: instance TermLike PlusLevel

+ Agda.Syntax.Internal.Generic: instance TermLike a => TermLike (Maybe a)

+ Agda.Syntax.Notation: stringParts :: Notation -> [String]

+ Agda.Syntax.Parser.Alex: alexGetByte :: AlexInput -> Maybe (Word8, AlexInput)

+ Agda.Syntax.Parser.Tokens: KwCOMPILED_JS :: Keyword

+ Agda.Syntax.Parser.Tokens: KwQuoteTerm :: Keyword

+ Agda.Syntax.Parser.Tokens: KwSTATIC :: Keyword

+ Agda.Syntax.Parser.Tokens: KwUnquote :: Keyword

+ Agda.Syntax.Parser.Tokens: SymDotDot :: Symbol

+ Agda.Syntax.Parser.Tokens: SymDoubleCloseBrace :: Symbol

+ Agda.Syntax.Parser.Tokens: SymDoubleOpenBrace :: Symbol

+ Agda.Syntax.Scope.Base: OnlyQualifiedNS :: NameSpaceId

+ Agda.Syntax.Scope.Base: allNamesInScope' :: InScope a => Scope -> ThingsInScope (a, Access)

+ Agda.Syntax.Scope.Base: instance Bounded NameSpaceId

+ Agda.Syntax.Scope.Base: instance Enum NameSpaceId

+ Agda.Syntax.Scope.Base: instance KillRange ScopeInfo

+ Agda.Syntax.Scope.Base: instance Show NameSpaceId

+ Agda.Syntax.Scope.Base: nameSpaceAccess :: NameSpaceId -> Access

+ Agda.Syntax.Scope.Base: removeOnlyQualified :: Scope -> Scope

+ Agda.Syntax.Scope.Base: scopeLookup' :: InScope a => QName -> ScopeInfo -> [(a, Access)]

+ Agda.Syntax.Scope.Base: scopeNameSpaces :: Scope -> [(NameSpaceId, NameSpace)]

+ Agda.Syntax.Scope.Base: setNameSpace :: NameSpaceId -> NameSpace -> Scope -> Scope

+ Agda.Syntax.Strict: instance Strict Level

+ Agda.Syntax.Strict: instance Strict LevelAtom

+ Agda.Syntax.Strict: instance Strict PlusLevel

+ Agda.Syntax.Strict: instance Strict a => Strict (Maybe a)

+ Agda.Syntax.Translation.AbstractToConcrete: instance (ToConcrete a1 c1, ToConcrete a2 c2) => ToConcrete (a1, a2) (c1, c2)

+ Agda.Syntax.Translation.AbstractToConcrete: instance (ToConcrete a1 c1, ToConcrete a2 c2, ToConcrete a3 c3) => ToConcrete (a1, a2, a3) (c1, c2, c3)

+ Agda.Syntax.Translation.AbstractToConcrete: instance ToConcrete (Constr Constructor) Declaration

+ Agda.Syntax.Translation.AbstractToConcrete: instance ToConcrete (DontTouchMe a) a

+ Agda.Syntax.Translation.AbstractToConcrete: instance ToConcrete (Maybe QName) (Maybe Name)

+ Agda.Syntax.Translation.AbstractToConcrete: instance ToConcrete AsWhereDecls WhereClause

+ Agda.Syntax.Translation.AbstractToConcrete: instance ToConcrete Clause [Declaration]

+ Agda.Syntax.Translation.AbstractToConcrete: instance ToConcrete Declaration [Declaration]

+ Agda.Syntax.Translation.AbstractToConcrete: instance ToConcrete Expr Expr

+ Agda.Syntax.Translation.AbstractToConcrete: instance ToConcrete LHS LHS

+ Agda.Syntax.Translation.AbstractToConcrete: instance ToConcrete LamBinding LamBinding

+ Agda.Syntax.Translation.AbstractToConcrete: instance ToConcrete LetBinding [Declaration]

+ Agda.Syntax.Translation.AbstractToConcrete: instance ToConcrete ModuleApplication ModuleApplication

+ Agda.Syntax.Translation.AbstractToConcrete: instance ToConcrete ModuleName QName

+ Agda.Syntax.Translation.AbstractToConcrete: instance ToConcrete Name Name

+ Agda.Syntax.Translation.AbstractToConcrete: instance ToConcrete Pattern Pattern

+ Agda.Syntax.Translation.AbstractToConcrete: instance ToConcrete QName QName

+ Agda.Syntax.Translation.AbstractToConcrete: instance ToConcrete RHS (RHS, [Expr], [Expr], [Declaration])

+ Agda.Syntax.Translation.AbstractToConcrete: instance ToConcrete RangeAndPragma Pragma

+ Agda.Syntax.Translation.AbstractToConcrete: instance ToConcrete TypedBinding TypedBinding

+ Agda.Syntax.Translation.AbstractToConcrete: instance ToConcrete TypedBindings TypedBindings

+ Agda.Syntax.Translation.AbstractToConcrete: instance ToConcrete a c => ToConcrete (Arg a) (Arg c)

+ Agda.Syntax.Translation.AbstractToConcrete: instance ToConcrete a c => ToConcrete (Named name a) (Named name c)

+ Agda.Syntax.Translation.AbstractToConcrete: instance ToConcrete a c => ToConcrete [a] [c]

+ Agda.Syntax.Translation.AbstractToConcrete: noTakenNames :: AbsToCon a -> AbsToCon a

+ Agda.Syntax.Translation.InternalToAbstract: instance (Free i, Reify i a) => Reify (Abs i) (Name, a)

+ Agda.Syntax.Translation.InternalToAbstract: instance DotVars Clause

+ Agda.Syntax.Translation.InternalToAbstract: instance DotVars RHS

+ Agda.Syntax.Translation.InternalToAbstract: instance Reify Elim Expr

+ Agda.Syntax.Translation.InternalToAbstract: instance Reify Level Expr

+ Agda.Termination.SparseMatrix: instance (Show i, Integral i, HasZero b, Pretty b) => Pretty (Matrix i b)

+ Agda.Termination.SparseMatrix: instance (Show i, Ord i, Integral i, Enum i, CoArbitrary b, HasZero b) => CoArbitrary (Matrix i b)

+ Agda.Termination.TermCheck: instance StripAllProjections Term

+ Agda.Termination.TermCheck: instance StripAllProjections a => StripAllProjections (Arg a)

+ Agda.Termination.TermCheck: instance StripAllProjections a => StripAllProjections [a]

+ Agda.TypeChecking.Abstract: instance (Raise a, AbstractTerm a) => AbstractTerm (Abs a)

+ Agda.TypeChecking.Abstract: instance AbstractTerm Level

+ Agda.TypeChecking.Abstract: instance AbstractTerm LevelAtom

+ Agda.TypeChecking.Abstract: instance AbstractTerm PlusLevel

+ Agda.TypeChecking.Abstract: instance AbstractTerm a => AbstractTerm (Maybe a)

+ Agda.TypeChecking.CompiledClause.Compile: compile :: Cls -> CompiledClauses

+ Agda.TypeChecking.CompiledClause.Compile: compileClauses :: Bool -> [Clause] -> TCM CompiledClauses

+ Agda.TypeChecking.CompiledClause.Compile: expandCatchAlls :: Int -> Cls -> Cls

+ Agda.TypeChecking.CompiledClause.Compile: nextSplit :: Cls -> Maybe Int

+ Agda.TypeChecking.CompiledClause.Compile: splitC :: Int -> Cl -> Case Cl

+ Agda.TypeChecking.CompiledClause.Compile: splitOn :: Int -> Cls -> Case Cls

+ Agda.TypeChecking.CompiledClause.Compile: substBody :: Int -> Integer -> Term -> ClauseBody -> ClauseBody

+ Agda.TypeChecking.CompiledClause.Compile: type Cl = ([Arg Pattern], ClauseBody)

+ Agda.TypeChecking.CompiledClause.Compile: type Cls = [Cl]

+ Agda.TypeChecking.Constraints: addConstraint :: Constraint -> TCM ()

+ Agda.TypeChecking.Constraints: ifNoConstraints :: TCM a -> (a -> TCM b) -> (ProblemId -> a -> TCM b) -> TCM b

+ Agda.TypeChecking.Constraints: ifNoConstraints_ :: TCM () -> TCM a -> (ProblemId -> TCM a) -> TCM a

+ Agda.TypeChecking.Constraints: localState :: MonadState s m => m a -> m a

+ Agda.TypeChecking.Constraints: newProblem :: TCM a -> TCM (ProblemId, a)

+ Agda.TypeChecking.Constraints: newProblem_ :: TCM () -> TCM ProblemId

+ Agda.TypeChecking.Constraints: solveAwakeConstraints :: TCM ()

+ Agda.TypeChecking.Constraints: wakeupConstraints_ :: TCM ()

+ Agda.TypeChecking.Constraints: whenConstraints :: TCM () -> TCM () -> TCM ()

+ Agda.TypeChecking.Conversion: compareElims :: [Polarity] -> Type -> Term -> [Elim] -> [Elim] -> TCM ()

+ Agda.TypeChecking.Conversion: compareTerm' :: Comparison -> Type -> Term -> Term -> TCM ()

+ Agda.TypeChecking.Conversion: intersectVars :: Args -> Args -> Maybe [Bool]

+ Agda.TypeChecking.Conversion: mlevel :: TCM (Maybe Term)

+ Agda.TypeChecking.Datatypes: isDataOrRecordType :: QName -> TCM Bool

+ Agda.TypeChecking.Eliminators: ConElim :: QName -> [Elim] -> ElimView

+ Agda.TypeChecking.Eliminators: DefElim :: QName -> [Elim] -> ElimView

+ Agda.TypeChecking.Eliminators: MetaElim :: MetaId -> [Elim] -> ElimView

+ Agda.TypeChecking.Eliminators: NoElim :: Term -> ElimView

+ Agda.TypeChecking.Eliminators: VarElim :: Nat -> [Elim] -> ElimView

+ Agda.TypeChecking.Eliminators: data ElimView

+ Agda.TypeChecking.Eliminators: elimView :: Term -> TCM ElimView

+ Agda.TypeChecking.Eliminators: unElim :: Term -> [Elim] -> Term

+ Agda.TypeChecking.Eliminators: unElimView :: ElimView -> Term

+ Agda.TypeChecking.Empty: isReallyEmptyType :: Type -> TCM ()

+ Agda.TypeChecking.Free: Flexible :: Occurrence

+ Agda.TypeChecking.Free: NoOccurrence :: Occurrence

+ Agda.TypeChecking.Free: StronglyRigid :: Occurrence

+ Agda.TypeChecking.Free: WeaklyRigid :: Occurrence

+ Agda.TypeChecking.Free: data Occurrence

+ Agda.TypeChecking.Free: instance Eq Occurrence

+ Agda.TypeChecking.Free: instance Free Level

+ Agda.TypeChecking.Free: instance Free LevelAtom

+ Agda.TypeChecking.Free: instance Free PlusLevel

+ Agda.TypeChecking.Free: instance Free a => Free (Maybe a)

+ Agda.TypeChecking.Free: instance Show Occurrence

+ Agda.TypeChecking.Free: irrelevantVars :: FreeVars -> VarSet

+ Agda.TypeChecking.Free: isBinderUsed :: Free a => Abs a -> Bool

+ Agda.TypeChecking.Free: occurrence :: Nat -> FreeVars -> Occurrence

+ Agda.TypeChecking.Free: relevantIn :: Free a => Nat -> a -> Bool

+ Agda.TypeChecking.Free: relevantVars :: FreeVars -> VarSet

+ Agda.TypeChecking.Free: stronglyRigidVars :: FreeVars -> VarSet

+ Agda.TypeChecking.Free: weaklyRigidVars :: FreeVars -> VarSet

+ Agda.TypeChecking.Irrelevance: applyRelevance :: Relevance -> Arg a -> Arg a

+ Agda.TypeChecking.Irrelevance: applyRelevanceToContext :: Relevance -> TCM a -> TCM a

+ Agda.TypeChecking.Irrelevance: composeRelevance :: Relevance -> Relevance -> Relevance

+ Agda.TypeChecking.Irrelevance: doWorkOnTypes :: TCM a -> TCM a

+ Agda.TypeChecking.Irrelevance: hideAndRelParams :: Arg a -> Arg a

+ Agda.TypeChecking.Irrelevance: ignoreForced :: Relevance -> Relevance

+ Agda.TypeChecking.Irrelevance: inverseApplyRelevance :: Relevance -> Arg a -> Arg a

+ Agda.TypeChecking.Irrelevance: inverseComposeRelevance :: Relevance -> Relevance -> Relevance

+ Agda.TypeChecking.Irrelevance: irrToNonStrict :: Relevance -> Relevance

+ Agda.TypeChecking.Irrelevance: modifyArgRelevance :: (Relevance -> Relevance) -> Arg a -> Arg a

+ Agda.TypeChecking.Irrelevance: nonStrictToIrr :: Relevance -> Relevance

+ Agda.TypeChecking.Irrelevance: unusableRelevance :: Relevance -> Bool

+ Agda.TypeChecking.Irrelevance: wakeIrrelevantVars :: TCM a -> TCM a

+ Agda.TypeChecking.Irrelevance: workOnTypes :: TCM a -> TCM a

+ Agda.TypeChecking.Irrelevance: workOnTypes' :: Bool -> TCM a -> TCM a

+ Agda.TypeChecking.Level: levelLub :: Level -> Level -> Level

+ Agda.TypeChecking.Level: lvlMax :: LevelKit -> Term -> Term -> Term

+ Agda.TypeChecking.Level: lvlSuc :: LevelKit -> Term -> Term

+ Agda.TypeChecking.Level: lvlType :: LevelKit -> Term

+ Agda.TypeChecking.Level: lvlZero :: LevelKit -> Term

+ Agda.TypeChecking.Level: reallyUnLevelView :: Level -> TCM Term

+ Agda.TypeChecking.LevelConstraints: instance Eq Leq

+ Agda.TypeChecking.LevelConstraints: instance Show Leq

+ Agda.TypeChecking.LevelConstraints: simplifyLevelConstraint :: Integer -> Constraint -> Constraints -> Constraint

+ Agda.TypeChecking.MetaVars: allVarOrIrrelevant :: Args -> Maybe [Arg Nat]

+ Agda.TypeChecking.MetaVars: assign :: MetaId -> Args -> Term -> TCM ()

+ Agda.TypeChecking.MetaVars: blockTermOnProblem :: Type -> Term -> ProblemId -> TCM Term

+ Agda.TypeChecking.MetaVars: checkAllVars :: Args -> TCM [Nat]

+ Agda.TypeChecking.MetaVars: newIFSMeta :: Type -> TCM Term

+ Agda.TypeChecking.MetaVars: newIFSMetaCtx :: Type -> Args -> TCM Term

+ Agda.TypeChecking.MetaVars: wakeupListener :: Listener -> TCM ()

+ Agda.TypeChecking.MetaVars.Mention: class MentionsMeta t

+ Agda.TypeChecking.MetaVars.Mention: instance (MentionsMeta a, MentionsMeta b) => MentionsMeta (a, b)

+ Agda.TypeChecking.MetaVars.Mention: instance (MentionsMeta a, MentionsMeta b, MentionsMeta c) => MentionsMeta (a, b, c)

+ Agda.TypeChecking.MetaVars.Mention: instance MentionsMeta Constraint

+ Agda.TypeChecking.MetaVars.Mention: instance MentionsMeta Elim

+ Agda.TypeChecking.MetaVars.Mention: instance MentionsMeta Level

+ Agda.TypeChecking.MetaVars.Mention: instance MentionsMeta LevelAtom

+ Agda.TypeChecking.MetaVars.Mention: instance MentionsMeta PlusLevel

+ Agda.TypeChecking.MetaVars.Mention: instance MentionsMeta ProblemConstraint

+ Agda.TypeChecking.MetaVars.Mention: instance MentionsMeta Sort

+ Agda.TypeChecking.MetaVars.Mention: instance MentionsMeta Term

+ Agda.TypeChecking.MetaVars.Mention: instance MentionsMeta Type

+ Agda.TypeChecking.MetaVars.Mention: instance MentionsMeta a => MentionsMeta (Closure a)

+ Agda.TypeChecking.MetaVars.Mention: instance MentionsMeta a => MentionsMeta (Tele a)

+ Agda.TypeChecking.MetaVars.Mention: instance MentionsMeta t => MentionsMeta (Abs t)

+ Agda.TypeChecking.MetaVars.Mention: instance MentionsMeta t => MentionsMeta (Arg t)

+ Agda.TypeChecking.MetaVars.Mention: instance MentionsMeta t => MentionsMeta (Maybe t)

+ Agda.TypeChecking.MetaVars.Mention: instance MentionsMeta t => MentionsMeta [t]

+ Agda.TypeChecking.MetaVars.Mention: mentionsMeta :: MentionsMeta t => MetaId -> t -> Bool

+ Agda.TypeChecking.MetaVars.Occurs: Irrel :: OccursCtx

+ Agda.TypeChecking.MetaVars.Occurs: NoUnfold :: UnfoldStrategy

+ Agda.TypeChecking.MetaVars.Occurs: NothingToPrune :: PruneResult

+ Agda.TypeChecking.MetaVars.Occurs: PrunedEverything :: PruneResult

+ Agda.TypeChecking.MetaVars.Occurs: PrunedNothing :: PruneResult

+ Agda.TypeChecking.MetaVars.Occurs: PrunedSomething :: PruneResult

+ Agda.TypeChecking.MetaVars.Occurs: StronglyRigid :: OccursCtx

+ Agda.TypeChecking.MetaVars.Occurs: YesUnfold :: UnfoldStrategy

+ Agda.TypeChecking.MetaVars.Occurs: allowedVar :: Nat -> Vars -> Bool

+ Agda.TypeChecking.MetaVars.Occurs: data PruneResult

+ Agda.TypeChecking.MetaVars.Occurs: data UnfoldStrategy

+ Agda.TypeChecking.MetaVars.Occurs: defArgs :: UnfoldStrategy -> OccursCtx -> OccursCtx

+ Agda.TypeChecking.MetaVars.Occurs: goIrrelevant :: Vars -> Vars

+ Agda.TypeChecking.MetaVars.Occurs: instance Eq PruneResult

+ Agda.TypeChecking.MetaVars.Occurs: instance Eq UnfoldStrategy

+ Agda.TypeChecking.MetaVars.Occurs: instance Occurs Level

+ Agda.TypeChecking.MetaVars.Occurs: instance Occurs LevelAtom

+ Agda.TypeChecking.MetaVars.Occurs: instance Occurs PlusLevel

+ Agda.TypeChecking.MetaVars.Occurs: instance Show PruneResult

+ Agda.TypeChecking.MetaVars.Occurs: instance Show UnfoldStrategy

+ Agda.TypeChecking.MetaVars.Occurs: prune :: MetaId -> Args -> [Nat] -> TCM PruneResult

+ Agda.TypeChecking.MetaVars.Occurs: strongly :: OccursCtx -> OccursCtx

+ Agda.TypeChecking.MetaVars.Occurs: takeRelevant :: Vars -> [Nat]

+ Agda.TypeChecking.MetaVars.Occurs: type Vars = ([Nat], [Nat])

+ Agda.TypeChecking.MetaVars.Occurs: underAbs :: Vars -> Vars

+ Agda.TypeChecking.MetaVars.Occurs: unfold :: UnfoldStrategy -> Term -> TCM (Blocked Term)

+ Agda.TypeChecking.MetaVars.Occurs: weakly :: OccursCtx -> OccursCtx

+ Agda.TypeChecking.Monad.Base: BuiltinData :: (TCM Type) -> [String] -> BuiltinDescriptor

+ Agda.TypeChecking.Monad.Base: BuiltinDataCons :: (TCM Type) -> BuiltinDescriptor

+ Agda.TypeChecking.Monad.Base: BuiltinInfo :: String -> BuiltinDescriptor -> BuiltinInfo

+ Agda.TypeChecking.Monad.Base: BuiltinPostulate :: (TCM Type) -> BuiltinDescriptor

+ Agda.TypeChecking.Monad.Base: BuiltinPrim :: String -> (Term -> TCM ()) -> BuiltinDescriptor

+ Agda.TypeChecking.Monad.Base: BuiltinUnknown :: (Maybe (TCM Type)) -> (Term -> TCM ()) -> BuiltinDescriptor

+ Agda.TypeChecking.Monad.Base: CallInfo :: Range -> String -> CallInfo

+ Agda.TypeChecking.Monad.Base: CheckConstraint :: Nat -> ProblemConstraint -> Listener

+ Agda.TypeChecking.Monad.Base: CheckIsEmpty :: Type -> (Maybe ()) -> Call

+ Agda.TypeChecking.Monad.Base: CheckWithFunctionType :: Expr -> (Maybe ()) -> Call

+ Agda.TypeChecking.Monad.Base: CompiledRep :: Maybe HaskellRepresentation -> Maybe EpicCode -> Maybe JSCode -> CompiledRepresentation

+ Agda.TypeChecking.Monad.Base: CoverageCantSplitIrrelevantType :: Type -> TypeError

+ Agda.TypeChecking.Monad.Base: DCon :: QName -> [Arg DisplayTerm] -> DisplayTerm

+ Agda.TypeChecking.Monad.Base: DDef :: QName -> [Arg DisplayTerm] -> DisplayTerm

+ Agda.TypeChecking.Monad.Base: DDot :: Term -> DisplayTerm

+ Agda.TypeChecking.Monad.Base: ElimCmp :: [Polarity] -> Type -> Term -> [Elim] -> [Elim] -> Constraint

+ Agda.TypeChecking.Monad.Base: EtaExpand :: MetaId -> Listener

+ Agda.TypeChecking.Monad.Base: FindInScope :: MetaId -> Constraint

+ Agda.TypeChecking.Monad.Base: Frozen :: Frozen

+ Agda.TypeChecking.Monad.Base: HeterogeneousEquality :: Term -> Type -> Term -> Type -> TypeError

+ Agda.TypeChecking.Monad.Base: IFSNoCandidateInScope :: Type -> TypeError

+ Agda.TypeChecking.Monad.Base: Instantiable :: Frozen

+ Agda.TypeChecking.Monad.Base: NothingAppliedToInstanceArg :: Expr -> TypeError

+ Agda.TypeChecking.Monad.Base: OpenIFS :: MetaInstantiation

+ Agda.TypeChecking.Monad.Base: PConstr :: ProblemId -> Closure Constraint -> ProblemConstraint

+ Agda.TypeChecking.Monad.Base: PersistentTCSt :: DecodedModules -> CommandLineOptions -> PersistentTCState

+ Agda.TypeChecking.Monad.Base: ProblemId :: Nat -> ProblemId

+ Agda.TypeChecking.Monad.Base: SafeFlagPostulate :: Name -> TypeError

+ Agda.TypeChecking.Monad.Base: SafeFlagPragma :: [String] -> TypeError

+ Agda.TypeChecking.Monad.Base: SafeFlagPrimTrustMe :: TypeError

+ Agda.TypeChecking.Monad.Base: TerminationError :: [QName] -> [CallInfo] -> TerminationError

+ Agda.TypeChecking.Monad.Base: WrongIrrelevanceInLambda :: Type -> TypeError

+ Agda.TypeChecking.Monad.Base: builtinDesc :: BuiltinInfo -> BuiltinDescriptor

+ Agda.TypeChecking.Monad.Base: builtinName :: BuiltinInfo -> String

+ Agda.TypeChecking.Monad.Base: callInfoCall :: CallInfo -> String

+ Agda.TypeChecking.Monad.Base: callInfoRange :: CallInfo -> Range

+ Agda.TypeChecking.Monad.Base: compiledEpic :: CompiledRepresentation -> Maybe EpicCode

+ Agda.TypeChecking.Monad.Base: compiledHaskell :: CompiledRepresentation -> Maybe HaskellRepresentation

+ Agda.TypeChecking.Monad.Base: compiledJS :: CompiledRepresentation -> Maybe JSCode

+ Agda.TypeChecking.Monad.Base: constraintProblem :: ProblemConstraint -> ProblemId

+ Agda.TypeChecking.Monad.Base: data BuiltinDescriptor

+ Agda.TypeChecking.Monad.Base: data BuiltinInfo

+ Agda.TypeChecking.Monad.Base: data CallInfo

+ Agda.TypeChecking.Monad.Base: data CompiledRepresentation

+ Agda.TypeChecking.Monad.Base: data Frozen

+ Agda.TypeChecking.Monad.Base: data Listener

+ Agda.TypeChecking.Monad.Base: data PersistentTCState

+ Agda.TypeChecking.Monad.Base: data ProblemConstraint

+ Agda.TypeChecking.Monad.Base: data TerminationError

+ Agda.TypeChecking.Monad.Base: defCompiledRep :: Definition -> CompiledRepresentation

+ Agda.TypeChecking.Monad.Base: defEpicDef :: Definition -> Maybe EpicCode

+ Agda.TypeChecking.Monad.Base: defJSDef :: Definition -> Maybe JSCode

+ Agda.TypeChecking.Monad.Base: envActiveProblems :: TCEnv -> [ProblemId]

+ Agda.TypeChecking.Monad.Base: envRelevance :: TCEnv -> Relevance

+ Agda.TypeChecking.Monad.Base: envSolvingConstraints :: TCEnv -> Bool

+ Agda.TypeChecking.Monad.Base: envTopLevel :: TCEnv -> Bool

+ Agda.TypeChecking.Monad.Base: fProblem :: FreshThings -> ProblemId

+ Agda.TypeChecking.Monad.Base: funStatic :: Defn -> Bool

+ Agda.TypeChecking.Monad.Base: instance Data CompiledRepresentation

+ Agda.TypeChecking.Monad.Base: instance Data ProblemId

+ Agda.TypeChecking.Monad.Base: instance Enum ProblemId

+ Agda.TypeChecking.Monad.Base: instance Eq CallInfo

+ Agda.TypeChecking.Monad.Base: instance Eq Frozen

+ Agda.TypeChecking.Monad.Base: instance Eq Listener

+ Agda.TypeChecking.Monad.Base: instance Eq ProblemId

+ Agda.TypeChecking.Monad.Base: instance Functor (Reduced no)

+ Agda.TypeChecking.Monad.Base: instance Functor Open

+ Agda.TypeChecking.Monad.Base: instance HasFresh ProblemId FreshThings

+ Agda.TypeChecking.Monad.Base: instance Integral ProblemId

+ Agda.TypeChecking.Monad.Base: instance Num ProblemId

+ Agda.TypeChecking.Monad.Base: instance Ord CallInfo

+ Agda.TypeChecking.Monad.Base: instance Ord Listener

+ Agda.TypeChecking.Monad.Base: instance Ord ProblemId

+ Agda.TypeChecking.Monad.Base: instance Real ProblemId

+ Agda.TypeChecking.Monad.Base: instance Show CallInfo

+ Agda.TypeChecking.Monad.Base: instance Show CompiledRepresentation

+ Agda.TypeChecking.Monad.Base: instance Show Frozen

+ Agda.TypeChecking.Monad.Base: instance Show Occ

+ Agda.TypeChecking.Monad.Base: instance Show OccPos

+ Agda.TypeChecking.Monad.Base: instance Show ProblemConstraint

+ Agda.TypeChecking.Monad.Base: instance Show ProblemId

+ Agda.TypeChecking.Monad.Base: instance Show TerminationError

+ Agda.TypeChecking.Monad.Base: instance Typeable CallInfo

+ Agda.TypeChecking.Monad.Base: instance Typeable CompiledRepresentation

+ Agda.TypeChecking.Monad.Base: instance Typeable Listener

+ Agda.TypeChecking.Monad.Base: instance Typeable ProblemConstraint

+ Agda.TypeChecking.Monad.Base: instance Typeable ProblemId

+ Agda.TypeChecking.Monad.Base: instance Typeable TerminationError

+ Agda.TypeChecking.Monad.Base: jMetaId :: Judgement t a -> a

+ Agda.TypeChecking.Monad.Base: jMetaType :: Judgement t a -> t

+ Agda.TypeChecking.Monad.Base: mvFrozen :: MetaVariable -> Frozen

+ Agda.TypeChecking.Monad.Base: newtype ProblemId

+ Agda.TypeChecking.Monad.Base: noCompiledRep :: CompiledRepresentation

+ Agda.TypeChecking.Monad.Base: stAwakeConstraints :: TCState -> Constraints

+ Agda.TypeChecking.Monad.Base: stExtLambdaTele :: TCState -> Map QName (Int, Int)

+ Agda.TypeChecking.Monad.Base: stPersistent :: TCState -> PersistentTCState

+ Agda.TypeChecking.Monad.Base: stSleepingConstraints :: TCState -> Constraints

+ Agda.TypeChecking.Monad.Base: termErrCalls :: TerminationError -> [CallInfo]

+ Agda.TypeChecking.Monad.Base: termErrFunctions :: TerminationError -> [QName]

+ Agda.TypeChecking.Monad.Base: theConstraint :: ProblemConstraint -> Closure Constraint

+ Agda.TypeChecking.Monad.Base: type JSCode = Exp

+ Agda.TypeChecking.Monad.Builtin: getBuiltinThing :: String -> TCM (Maybe (Builtin PrimFun))

+ Agda.TypeChecking.Monad.Builtin: primInteger, primAgdaRecordDef, primAgdaDataDef, primAgdaFunDef, primAgdaDefinitionDataConstructor, primAgdaDefinitionPrimitive, primAgdaDefinitionPostulate, primAgdaDefinitionRecordDef, primAgdaDefinitionDataDef, primAgdaDefinitionFunDef, primAgdaDefinition, primAgdaSortUnsupported, primAgdaSortLit, primAgdaSortSet, primAgdaSort, primIrrelevant, primRelevant, primRelvance, primVisible, primInstance, primHidden, primHiding, primAgdaTypeEl, primAgdaType, primAgdaTermUnsupported, primAgdaTermSort, primAgdaTermPi, primAgdaTermCon, primAgdaTermDef, primAgdaTermLam, primAgdaTermVar, primAgdaTerm, primArgArg, primArg, primQName, primLevelMax, primLevelSuc, primLevelZero, primLevel, primRefl, primEquality, primFlat, primSharp, primInf, primSizeInf, primSizeSuc, primSize, primNatLess, primNatEquality, primNatModSucAux, primNatDivSucAux, primNatTimes, primNatMinus, primNatPlus, primZero, primSuc, primNat, primIO, primCons, primNil, primList, primFalse, primTrue, primBool, primString, primChar, primFloat :: TCM Term

+ Agda.TypeChecking.Monad.Constraints: addAwakeConstraints :: Constraints -> TCM ()

+ Agda.TypeChecking.Monad.Constraints: addConstraint' :: Constraint -> TCM ()

+ Agda.TypeChecking.Monad.Constraints: buildProblemConstraint :: ProblemId -> Constraint -> TCM ProblemConstraint

+ Agda.TypeChecking.Monad.Constraints: currentProblem :: TCM ProblemId

+ Agda.TypeChecking.Monad.Constraints: getAllConstraints :: TCM Constraints

+ Agda.TypeChecking.Monad.Constraints: getAwakeConstraints :: TCM Constraints

+ Agda.TypeChecking.Monad.Constraints: getConstraintsForProblem :: ProblemId -> TCM Constraints

+ Agda.TypeChecking.Monad.Constraints: isProblemSolved :: ProblemId -> TCM Bool

+ Agda.TypeChecking.Monad.Constraints: isSolvingConstraints :: TCM Bool

+ Agda.TypeChecking.Monad.Constraints: nowSolvingConstraints :: TCM a -> TCM a

+ Agda.TypeChecking.Monad.Constraints: solvingProblem :: ProblemId -> TCM a -> TCM a

+ Agda.TypeChecking.Monad.Constraints: stealConstraints :: ProblemId -> TCM ()

+ Agda.TypeChecking.Monad.Constraints: takeAwakeConstraint :: TCM (Maybe ProblemConstraint)

+ Agda.TypeChecking.Monad.Constraints: wakeConstraints :: (ProblemConstraint -> Bool) -> TCM ()

+ Agda.TypeChecking.Monad.Context: addContext :: MonadTCM tcm => [Arg (Name, Type)] -> tcm a -> tcm a

+ Agda.TypeChecking.Monad.Context: addCtxString :: MonadTCM tcm => String -> Arg Type -> tcm a -> tcm a

+ Agda.TypeChecking.Monad.Context: modifyContext :: MonadTCM tcm => (Context -> Context) -> tcm a -> tcm a

+ Agda.TypeChecking.Monad.Context: modifyContextEntries :: (Arg (Name, Type) -> Arg (Name, Type)) -> Context -> Context

+ Agda.TypeChecking.Monad.Context: modifyContextEntry :: (Arg (Name, Type) -> Arg (Name, Type)) -> ContextEntry -> ContextEntry

+ Agda.TypeChecking.Monad.Env: leaveTopLevel :: TCM a -> TCM a

+ Agda.TypeChecking.Monad.Env: onTopLevel :: TCM Bool

+ Agda.TypeChecking.Monad.Exception: instance (Monad m, MonadException err m) => MonadException err (ReaderT r m)

+ Agda.TypeChecking.Monad.Exception: instance (Monad m, MonadException err m, Monoid w) => MonadException err (WriterT w m)

+ Agda.TypeChecking.Monad.MetaVars: freezeMetas :: TCM ()

+ Agda.TypeChecking.Monad.MetaVars: isFrozen :: MetaId -> TCM Bool

+ Agda.TypeChecking.Monad.MetaVars: modifyMetaStore :: (MetaStore -> MetaStore) -> TCM ()

+ Agda.TypeChecking.Monad.MetaVars: unfreezeMetas :: TCM ()

+ Agda.TypeChecking.Monad.Signature: addJSCode :: QName -> String -> TCM ()

+ Agda.TypeChecking.Monad.Signature: makeProjection :: QName -> TCM ()

+ Agda.TypeChecking.Monad.Signature: markStatic :: QName -> TCM ()

+ Agda.TypeChecking.Monad.SizedTypes: isSizeNameTest :: TCM (QName -> Bool)

+ Agda.TypeChecking.Monad.SizedTypes: isSizeTypeTest :: TCM (Type -> Bool)

+ Agda.TypeChecking.Monad.State: addExtLambdaTele :: QName -> (Int, Int) -> TCM ()

+ Agda.TypeChecking.Monad.State: getExtLambdaTele :: TCM (Map QName (Int, Int))

+ Agda.TypeChecking.Monad.State: resetAllState :: TCM ()

+ Agda.TypeChecking.Monad.State: setExtLambdaTele :: Map QName (Int, Int) -> TCM ()

+ Agda.TypeChecking.Monad.Statistics: tickMax :: String -> Integer -> TCM ()

+ Agda.TypeChecking.Monad.Statistics: tickN :: String -> Integer -> TCM ()

+ Agda.TypeChecking.Polarity: instance HasPolarity Level

+ Agda.TypeChecking.Polarity: instance HasPolarity LevelAtom

+ Agda.TypeChecking.Polarity: instance HasPolarity PlusLevel

+ Agda.TypeChecking.Positivity: instance ComputeOccurrences Level

+ Agda.TypeChecking.Positivity: instance ComputeOccurrences LevelAtom

+ Agda.TypeChecking.Positivity: instance ComputeOccurrences PlusLevel

+ Agda.TypeChecking.Pretty: ($$, <+>, <>) :: TCM Doc -> TCM Doc -> TCM Doc

+ Agda.TypeChecking.Pretty: empty, comma :: TCM Doc

+ Agda.TypeChecking.Pretty: instance PrettyTCM Elim

+ Agda.TypeChecking.Pretty: instance PrettyTCM Level

+ Agda.TypeChecking.Pretty: instance PrettyTCM ProblemConstraint

+ Agda.TypeChecking.Pretty: sep, vcat, hsep, fsep :: [TCM Doc] -> TCM Doc

+ Agda.TypeChecking.Pretty: text :: String -> TCM Doc

+ Agda.TypeChecking.Primitive: (<@>, <#>) :: TCM Term -> TCM Term -> TCM Term

+ Agda.TypeChecking.Primitive: hPi, nPi :: String -> TCM Type -> TCM Type -> TCM Type

+ Agda.TypeChecking.Primitive: instance PrimTerm Type

+ Agda.TypeChecking.Primitive: instance ToTerm Type

+ Agda.TypeChecking.Primitive: mkPrimFun1TCM :: (FromTerm a, ToTerm b) => TCM Type -> (a -> TCM b) -> TCM PrimitiveImpl

+ Agda.TypeChecking.Primitive: mkPrimLevelMax :: TCM PrimitiveImpl

+ Agda.TypeChecking.Primitive: mkPrimLevelSuc :: TCM PrimitiveImpl

+ Agda.TypeChecking.Primitive: mkPrimLevelZero :: TCM PrimitiveImpl

+ Agda.TypeChecking.Primitive: primDataConstructors :: TCM PrimitiveImpl

+ Agda.TypeChecking.Primitive: primQNameDefinition :: TCM PrimitiveImpl

+ Agda.TypeChecking.Primitive: primQNameType :: TCM PrimitiveImpl

+ Agda.TypeChecking.Quote: choice :: Monad m => [(m Bool, m a)] -> m a -> m a

+ Agda.TypeChecking.Quote: class Unquote a

+ Agda.TypeChecking.Quote: instance Unquote Hiding

+ Agda.TypeChecking.Quote: instance Unquote Integer

+ Agda.TypeChecking.Quote: instance Unquote Level

+ Agda.TypeChecking.Quote: instance Unquote QName

+ Agda.TypeChecking.Quote: instance Unquote Relevance

+ Agda.TypeChecking.Quote: instance Unquote Sort

+ Agda.TypeChecking.Quote: instance Unquote Term

+ Agda.TypeChecking.Quote: instance Unquote Type

+ Agda.TypeChecking.Quote: instance Unquote a => Unquote (Abs a)

+ Agda.TypeChecking.Quote: instance Unquote a => Unquote (Arg a)

+ Agda.TypeChecking.Quote: instance Unquote a => Unquote [a]

+ Agda.TypeChecking.Quote: isCon :: QName -> TCM Term -> TCM Bool

+ Agda.TypeChecking.Quote: quotingKit :: TCM (Term -> Term, Type -> Term)

+ Agda.TypeChecking.Quote: unquote :: Unquote a => Term -> TCM a

+ Agda.TypeChecking.Quote: unquoteFailed :: String -> String -> Term -> TCM a

+ Agda.TypeChecking.Quote: unquoteFailedGeneric :: String -> TCM a

+ Agda.TypeChecking.Quote: unquoteH :: Unquote a => Arg Term -> TCM a

+ Agda.TypeChecking.Quote: unquoteN :: Unquote a => Arg Term -> TCM a

+ Agda.TypeChecking.Records: findPossibleRecords :: [Name] -> TCM [QName]

+ Agda.TypeChecking.Records: isEtaRecordType :: Type -> TCM (Maybe (QName, Args))

+ Agda.TypeChecking.Records: isSingletonRecord' :: Bool -> QName -> Args -> TCM (Either MetaId Bool)

+ Agda.TypeChecking.Records: isSingletonRecordModuloRelevance :: QName -> Args -> TCM (Either MetaId Bool)

+ Agda.TypeChecking.Reduce: instance (Raise a, InstantiateFull a) => InstantiateFull (Tele a)

+ Agda.TypeChecking.Reduce: instance (Raise a, Normalise a) => Normalise (Tele a)

+ Agda.TypeChecking.Reduce: instance (Raise t, InstantiateFull t) => InstantiateFull (Abs t)

+ Agda.TypeChecking.Reduce: instance (Raise t, Normalise t) => Normalise (Abs t)

+ Agda.TypeChecking.Reduce: instance (Raise t, Reduce t) => Reduce (Abs t)

+ Agda.TypeChecking.Reduce: instance Instantiate Elim

+ Agda.TypeChecking.Reduce: instance Instantiate Level

+ Agda.TypeChecking.Reduce: instance Instantiate LevelAtom

+ Agda.TypeChecking.Reduce: instance Instantiate PlusLevel

+ Agda.TypeChecking.Reduce: instance InstantiateFull Elim

+ Agda.TypeChecking.Reduce: instance InstantiateFull Level

+ Agda.TypeChecking.Reduce: instance InstantiateFull LevelAtom

+ Agda.TypeChecking.Reduce: instance InstantiateFull PlusLevel

+ Agda.TypeChecking.Reduce: instance InstantiateFull ProblemConstraint

+ Agda.TypeChecking.Reduce: instance Normalise Elim

+ Agda.TypeChecking.Reduce: instance Normalise Level

+ Agda.TypeChecking.Reduce: instance Normalise LevelAtom

+ Agda.TypeChecking.Reduce: instance Normalise PlusLevel

+ Agda.TypeChecking.Reduce: instance Normalise ProblemConstraint

+ Agda.TypeChecking.Reduce: instance Reduce Elim

+ Agda.TypeChecking.Reduce: instance Reduce Level

+ Agda.TypeChecking.Reduce: instance Reduce LevelAtom

+ Agda.TypeChecking.Reduce: instance Reduce PlusLevel

+ Agda.TypeChecking.Rules.Decl: checkSectionApplication' :: ModuleInfo -> ModuleName -> ModuleApplication -> Map QName QName -> Map ModuleName ModuleName -> TCM ()

+ Agda.TypeChecking.Rules.Def: checkFunDef' :: Type -> Relevance -> Delayed -> DefInfo -> QName -> [Clause] -> TCM ()

+ Agda.TypeChecking.Rules.LHS.Problem: instance Raise (Problem' p)

+ Agda.TypeChecking.Rules.LHS.Unify: DefSh :: QName -> ShapeView a

+ Agda.TypeChecking.Rules.LHS.Unify: Definitely :: Unifiable

+ Agda.TypeChecking.Rules.LHS.Unify: ElseSh :: ShapeView a

+ Agda.TypeChecking.Rules.LHS.Unify: FunSh :: (Arg a) -> a -> ShapeView a

+ Agda.TypeChecking.Rules.LHS.Unify: Het :: a -> a -> HomHet a

+ Agda.TypeChecking.Rules.LHS.Unify: Hom :: a -> HomHet a

+ Agda.TypeChecking.Rules.LHS.Unify: LitSh :: Literal -> ShapeView a

+ Agda.TypeChecking.Rules.LHS.Unify: MayNotPostpone :: UnifyMayPostpone

+ Agda.TypeChecking.Rules.LHS.Unify: MayPostpone :: UnifyMayPostpone

+ Agda.TypeChecking.Rules.LHS.Unify: MetaSh :: ShapeView a

+ Agda.TypeChecking.Rules.LHS.Unify: PiSh :: (Arg a) -> (Abs a) -> ShapeView a

+ Agda.TypeChecking.Rules.LHS.Unify: Possibly :: Unifiable

+ Agda.TypeChecking.Rules.LHS.Unify: SortSh :: ShapeView a

+ Agda.TypeChecking.Rules.LHS.Unify: StronglyRigidOccurrence :: Type -> Term -> Term -> UnifyException

+ Agda.TypeChecking.Rules.LHS.Unify: VarSh :: Nat -> ShapeView a

+ Agda.TypeChecking.Rules.LHS.Unify: absAppHH :: SubstHH t tHH => Abs t -> TermHH -> tHH

+ Agda.TypeChecking.Rules.LHS.Unify: addEqualityHH :: TypeHH -> Term -> Term -> Unify ()

+ Agda.TypeChecking.Rules.LHS.Unify: applyHH :: ApplyHH t => t -> HomHet Args -> HomHet t

+ Agda.TypeChecking.Rules.LHS.Unify: askPostpone :: Unify UnifyMayPostpone

+ Agda.TypeChecking.Rules.LHS.Unify: checkEquality :: Type -> Term -> Term -> TCM ()

+ Agda.TypeChecking.Rules.LHS.Unify: checkEqualityHH :: TypeHH -> Term -> Term -> Unify ()

+ Agda.TypeChecking.Rules.LHS.Unify: class ApplyHH t

+ Agda.TypeChecking.Rules.LHS.Unify: class SubstHH t tHH

+ Agda.TypeChecking.Rules.LHS.Unify: class UReduce t

+ Agda.TypeChecking.Rules.LHS.Unify: constructorMismatchHH :: TypeHH -> Term -> Term -> Unify a

+ Agda.TypeChecking.Rules.LHS.Unify: data HomHet a

+ Agda.TypeChecking.Rules.LHS.Unify: data ShapeView a

+ Agda.TypeChecking.Rules.LHS.Unify: data Unifiable

+ Agda.TypeChecking.Rules.LHS.Unify: data UnifyMayPostpone

+ Agda.TypeChecking.Rules.LHS.Unify: dataOrRecordType' :: QName -> Type -> TCM (Maybe (QName, Type, Args))

+ Agda.TypeChecking.Rules.LHS.Unify: dataOrRecordTypeHH :: QName -> TypeHH -> TCM (Maybe TypeHH)

+ Agda.TypeChecking.Rules.LHS.Unify: emptyUOutput :: UnifyOutput

+ Agda.TypeChecking.Rules.LHS.Unify: forceHom :: TypeHH -> TCM Type

+ Agda.TypeChecking.Rules.LHS.Unify: fromHom :: HomHet a -> a

+ Agda.TypeChecking.Rules.LHS.Unify: ifClean :: Unify () -> Unify a -> Unify a -> Unify a

+ Agda.TypeChecking.Rules.LHS.Unify: instance (Eq a, Raise a) => Eq (ShapeView a)

+ Agda.TypeChecking.Rules.LHS.Unify: instance (Free a, Subst a) => SubstHH (HomHet a) (HomHet a)

+ Agda.TypeChecking.Rules.LHS.Unify: instance (Ord a, Raise a) => Ord (ShapeView a)

+ Agda.TypeChecking.Rules.LHS.Unify: instance (SubstHH a a', SubstHH b b') => SubstHH (a, b) (a', b')

+ Agda.TypeChecking.Rules.LHS.Unify: instance ApplyHH Term

+ Agda.TypeChecking.Rules.LHS.Unify: instance ApplyHH Type

+ Agda.TypeChecking.Rules.LHS.Unify: instance Data a => Data (HomHet a)

+ Agda.TypeChecking.Rules.LHS.Unify: instance Data a => Data (ShapeView a)

+ Agda.TypeChecking.Rules.LHS.Unify: instance Eq a => Eq (HomHet a)

+ Agda.TypeChecking.Rules.LHS.Unify: instance Foldable HomHet

+ Agda.TypeChecking.Rules.LHS.Unify: instance Functor HomHet

+ Agda.TypeChecking.Rules.LHS.Unify: instance Functor ShapeView

+ Agda.TypeChecking.Rules.LHS.Unify: instance MonadWriter UnifyOutput Unify

+ Agda.TypeChecking.Rules.LHS.Unify: instance Monoid Unifiable

+ Agda.TypeChecking.Rules.LHS.Unify: instance Ord a => Ord (HomHet a)

+ Agda.TypeChecking.Rules.LHS.Unify: instance PrettyTCM a => PrettyTCM (HomHet a)

+ Agda.TypeChecking.Rules.LHS.Unify: instance Raise a => Raise (HomHet a)

+ Agda.TypeChecking.Rules.LHS.Unify: instance Show a => Show (HomHet a)

+ Agda.TypeChecking.Rules.LHS.Unify: instance Show a => Show (ShapeView a)

+ Agda.TypeChecking.Rules.LHS.Unify: instance Subst a => Subst (HomHet a)

+ Agda.TypeChecking.Rules.LHS.Unify: instance SubstHH Term (HomHet Term)

+ Agda.TypeChecking.Rules.LHS.Unify: instance SubstHH Type (HomHet Type)

+ Agda.TypeChecking.Rules.LHS.Unify: instance SubstHH a b => SubstHH (Abs a) (Abs b)

+ Agda.TypeChecking.Rules.LHS.Unify: instance SubstHH a b => SubstHH (Arg a) (Arg b)

+ Agda.TypeChecking.Rules.LHS.Unify: instance SubstHH a b => SubstHH (Tele a) (Tele b)

+ Agda.TypeChecking.Rules.LHS.Unify: instance Traversable HomHet

+ Agda.TypeChecking.Rules.LHS.Unify: instance Typeable1 HomHet

+ Agda.TypeChecking.Rules.LHS.Unify: instance Typeable1 ShapeView

+ Agda.TypeChecking.Rules.LHS.Unify: instance UReduce Term

+ Agda.TypeChecking.Rules.LHS.Unify: instance UReduce Type

+ Agda.TypeChecking.Rules.LHS.Unify: instance UReduce t => UReduce (HomHet t)

+ Agda.TypeChecking.Rules.LHS.Unify: instance UReduce t => UReduce (Maybe t)

+ Agda.TypeChecking.Rules.LHS.Unify: isEtaRecordTypeHH :: MonadTCM tcm => TypeHH -> tcm (Maybe (QName, HomHet Args))

+ Agda.TypeChecking.Rules.LHS.Unify: isHom :: HomHet a -> Bool

+ Agda.TypeChecking.Rules.LHS.Unify: leftHH :: HomHet a -> a

+ Agda.TypeChecking.Rules.LHS.Unify: noPostponing :: Unify a -> Unify a

+ Agda.TypeChecking.Rules.LHS.Unify: reportPostponing :: Unify ()

+ Agda.TypeChecking.Rules.LHS.Unify: rightHH :: HomHet a -> a

+ Agda.TypeChecking.Rules.LHS.Unify: shapeView :: Type -> Unify (Type, ShapeView Type)

+ Agda.TypeChecking.Rules.LHS.Unify: shapeViewHH :: TypeHH -> Unify (TypeHH, ShapeView TypeHH)

+ Agda.TypeChecking.Rules.LHS.Unify: substHH :: SubstHH t tHH => TermHH -> t -> tHH

+ Agda.TypeChecking.Rules.LHS.Unify: substUnderHH :: SubstHH t tHH => Nat -> TermHH -> t -> tHH

+ Agda.TypeChecking.Rules.LHS.Unify: telViewUpToHH :: Int -> TypeHH -> Unify TelViewHH

+ Agda.TypeChecking.Rules.LHS.Unify: trivialHH :: SubstHH t tHH => t -> tHH

+ Agda.TypeChecking.Rules.LHS.Unify: type TelHH = Tele (Arg TypeHH)

+ Agda.TypeChecking.Rules.LHS.Unify: type TelViewHH = TelV TypeHH

+ Agda.TypeChecking.Rules.LHS.Unify: type TermHH = HomHet Term

+ Agda.TypeChecking.Rules.LHS.Unify: type TypeHH = HomHet Type

+ Agda.TypeChecking.Rules.LHS.Unify: type UnifyEnv = UnifyMayPostpone

+ Agda.TypeChecking.Rules.LHS.Unify: type UnifyOutput = Unifiable

+ Agda.TypeChecking.Rules.Term: LamNotPi :: LamOrPi

+ Agda.TypeChecking.Rules.Term: PiNotLam :: LamOrPi

+ Agda.TypeChecking.Rules.Term: checkLambda :: Arg TypedBinding -> Expr -> Type -> TCM Term

+ Agda.TypeChecking.Rules.Term: checkMeta :: (Type -> TCM Term) -> Type -> MetaInfo -> TCM Term

+ Agda.TypeChecking.Rules.Term: checkTerm :: Term -> Type -> TCM Term

+ Agda.TypeChecking.Rules.Term: data LamOrPi

+ Agda.TypeChecking.Rules.Term: inferMeta :: (Type -> TCM Term) -> MetaInfo -> TCM (Args -> Term, Type)

+ Agda.TypeChecking.Rules.Term: instance Eq LamOrPi

+ Agda.TypeChecking.Rules.Term: instance Show LamOrPi

+ Agda.TypeChecking.Rules.Term: isTypeEqualTo :: Expr -> Type -> TCM Type

+ Agda.TypeChecking.Rules.Term: leqType_ :: Type -> Type -> TCM ()

+ Agda.TypeChecking.Serialise: instance [incoherent] EmbPrj ()

+ Agda.TypeChecking.Serialise: instance [incoherent] EmbPrj CompiledRepresentation

+ Agda.TypeChecking.Serialise: instance [incoherent] EmbPrj EInterface

+ Agda.TypeChecking.Serialise: instance [incoherent] EmbPrj Exp

+ Agda.TypeChecking.Serialise: instance [incoherent] EmbPrj Forced

+ Agda.TypeChecking.Serialise: instance [incoherent] EmbPrj GlobalId

+ Agda.TypeChecking.Serialise: instance [incoherent] EmbPrj InjectiveFun

+ Agda.TypeChecking.Serialise: instance [incoherent] EmbPrj Level

+ Agda.TypeChecking.Serialise: instance [incoherent] EmbPrj LevelAtom

+ Agda.TypeChecking.Serialise: instance [incoherent] EmbPrj LocalId

+ Agda.TypeChecking.Serialise: instance [incoherent] EmbPrj MemberId

+ Agda.TypeChecking.Serialise: instance [incoherent] EmbPrj NameSpaceId

+ Agda.TypeChecking.Serialise: instance [incoherent] EmbPrj PlusLevel

+ Agda.TypeChecking.Serialise: instance [incoherent] EmbPrj Tag

+ Agda.TypeChecking.Serialise: instance [incoherent] Eq TypeRep'

+ Agda.TypeChecking.Serialise: instance [incoherent] Hashable TypeRep'

+ Agda.TypeChecking.Substitute: absBody :: Raise t => Abs t -> t

+ Agda.TypeChecking.Substitute: data TelV a

+ Agda.TypeChecking.Substitute: instance (Eq a, Raise a) => Eq (TelV a)

+ Agda.TypeChecking.Substitute: instance (Ord a, Raise a) => Ord (TelV a)

+ Agda.TypeChecking.Substitute: instance (Raise a, Eq a) => Eq (Abs a)

+ Agda.TypeChecking.Substitute: instance (Raise a, Eq a) => Eq (Tele a)

+ Agda.TypeChecking.Substitute: instance (Raise a, Ord a) => Ord (Abs a)

+ Agda.TypeChecking.Substitute: instance (Raise a, Ord a) => Ord (Tele a)

+ Agda.TypeChecking.Substitute: instance Data a => Data (TelV a)

+ Agda.TypeChecking.Substitute: instance Eq Constraint

+ Agda.TypeChecking.Substitute: instance Eq Elim

+ Agda.TypeChecking.Substitute: instance Eq Level

+ Agda.TypeChecking.Substitute: instance Eq LevelAtom

+ Agda.TypeChecking.Substitute: instance Eq PlusLevel

+ Agda.TypeChecking.Substitute: instance Eq Sort

+ Agda.TypeChecking.Substitute: instance Eq Term

+ Agda.TypeChecking.Substitute: instance Eq Type

+ Agda.TypeChecking.Substitute: instance Functor TelV

+ Agda.TypeChecking.Substitute: instance Ord Elim

+ Agda.TypeChecking.Substitute: instance Ord Level

+ Agda.TypeChecking.Substitute: instance Ord LevelAtom

+ Agda.TypeChecking.Substitute: instance Ord PlusLevel

+ Agda.TypeChecking.Substitute: instance Ord Sort

+ Agda.TypeChecking.Substitute: instance Ord Term

+ Agda.TypeChecking.Substitute: instance Ord Type

+ Agda.TypeChecking.Substitute: instance Raise ()

+ Agda.TypeChecking.Substitute: instance Raise ClauseBody

+ Agda.TypeChecking.Substitute: instance Raise Constraint

+ Agda.TypeChecking.Substitute: instance Raise Elim

+ Agda.TypeChecking.Substitute: instance Raise Level

+ Agda.TypeChecking.Substitute: instance Raise LevelAtom

+ Agda.TypeChecking.Substitute: instance Raise PlusLevel

+ Agda.TypeChecking.Substitute: instance Show a => Show (TelV a)

+ Agda.TypeChecking.Substitute: instance Subst Level

+ Agda.TypeChecking.Substitute: instance Subst LevelAtom

+ Agda.TypeChecking.Substitute: instance Subst PlusLevel

+ Agda.TypeChecking.Substitute: instance Typeable1 TelV

+ Agda.TypeChecking.Substitute: levelMax :: [PlusLevel] -> Level

+ Agda.TypeChecking.Substitute: levelSort :: Level -> Sort

+ Agda.TypeChecking.Substitute: levelTm :: Level -> Term

+ Agda.TypeChecking.Substitute: lvlView :: Term -> Level

+ Agda.TypeChecking.Substitute: mkAbs :: (Raise a, Free a) => String -> a -> Abs a

+ Agda.TypeChecking.Substitute: reAbs :: (Raise a, Free a) => Abs a -> Abs a

+ Agda.TypeChecking.Substitute: rename :: Raise t => (Nat -> Nat) -> t -> t

+ Agda.TypeChecking.Substitute: renameFrom :: Raise t => Nat -> (Nat -> Nat) -> t -> t

+ Agda.TypeChecking.Substitute: sLub :: Sort -> Sort -> Sort

+ Agda.TypeChecking.Substitute: sortTm :: Sort -> Term

+ Agda.TypeChecking.Substitute: telFromList :: [Arg (String, Type)] -> Telescope

+ Agda.TypeChecking.Substitute: telToList :: Telescope -> [Arg (String, Type)]

+ Agda.TypeChecking.Substitute: teleLam :: Telescope -> Term -> Term

+ Agda.TypeChecking.Substitute: type TelView = TelV Type

+ Agda.TypeChecking.Telescope: renameP :: Subst t => Permutation -> t -> t

+ Agda.TypeChecking.Telescope: reorderTel_ :: [Arg Type] -> Permutation

+ Agda.TypeChecking.Test.Generators: instance KillVar a => KillVar (Maybe a)

+ Agda.Utils.Graph: instance (Eq n, Eq e) => Eq (Graph n e)

+ Agda.Utils.Graph: instance Functor (Graph n)

+ Agda.Utils.IO.UTF8: hPutStr :: Handle -> String -> IO ()

+ Agda.Utils.List: isSublistOf :: Eq a => [a] -> [a] -> Bool

+ Agda.Utils.List: prop_uniqBy :: [Integer] -> Bool

+ Agda.Utils.List: prop_zipWith' :: (Integer -> Integer -> Integer) -> Property

+ Agda.Utils.List: uniqBy :: Ord b => (a -> b) -> [a] -> [a]

+ Agda.Utils.List: zipWith' :: (a -> b -> c) -> [a] -> [b] -> [c]

+ Agda.Utils.ReadP: parse' :: ReadP t a -> [t] -> Either a [t]

+ Agda.Utils.Size: instance Sized a => Sized (Maybe a)

+ Agda.Utils.VarSet: delete :: Ord a => a -> Set a -> Set a

+ Agda.Utils.VarSet: empty :: Set a

+ Agda.Utils.VarSet: fromList :: Ord a => [a] -> Set a

+ Agda.Utils.VarSet: isSubsetOf :: Ord a => Set a -> Set a -> Bool

+ Agda.Utils.VarSet: member :: Ord a => a -> Set a -> Bool

+ Agda.Utils.VarSet: singleton :: a -> Set a

+ Agda.Utils.VarSet: subtract :: Integer -> VarSet -> VarSet

+ Agda.Utils.VarSet: toList :: Set a -> [a]

+ Agda.Utils.VarSet: type VarSet = Set Integer

+ Agda.Utils.VarSet: union :: Ord a => Set a -> Set a -> Set a

+ Agda.Utils.VarSet: unions :: Ord a => [Set a] -> Set a

- Agda.Auto.Convert: frommyClause :: (CSCtx O, [CSPat O], Maybe (MExp O)) -> IO Clause

+ Agda.Auto.Convert: frommyClause :: (CSCtx O, [CSPat O], Maybe (MExp O)) -> ErrorT String IO Clause

- Agda.Auto.Convert: frommyExp :: MExp O -> IO Term

+ Agda.Auto.Convert: frommyExp :: MExp O -> ErrorT String IO Term

- Agda.Auto.Convert: frommyExps :: Nat -> MArgList O -> Term -> IO Term

+ Agda.Auto.Convert: frommyExps :: Nat -> MArgList O -> Term -> ErrorT String IO Term

- Agda.Compiler.Epic.AuxAST: EpicFun :: Var -> Comment -> String -> Fun

+ Agda.Compiler.Epic.AuxAST: EpicFun :: Var -> Maybe QName -> Comment -> String -> Fun

- Agda.Compiler.Epic.AuxAST: Fun :: Inline -> Var -> Comment -> [Var] -> Expr -> Fun

+ Agda.Compiler.Epic.AuxAST: Fun :: Inline -> Var -> Maybe QName -> Comment -> [Var] -> Expr -> Fun

- Agda.Compiler.Epic.CompileState: CompileState :: Map QName Tag -> [Var] -> Set Var -> Map QName Bool -> Map QName Int -> Maybe QName -> Map QName IrrFilter -> CompileState

+ Agda.Compiler.Epic.CompileState: CompileState :: [Var] -> Map TopLevelModuleName (EInterface, Set FilePath) -> EInterface -> EInterface -> String -> CompileState

- Agda.Compiler.Epic.CompileState: addDefName :: Monad m => QName -> Compile m ()

+ Agda.Compiler.Epic.CompileState: addDefName :: QName -> Compile TCM ()

- Agda.Compiler.Epic.CompileState: constructorArity :: (MonadTCM tcm, Num a) => QName -> tcm a

+ Agda.Compiler.Epic.CompileState: constructorArity :: Num a => QName -> TCM a

- Agda.Compiler.Epic.CompileState: epicError :: MonadTCM m => String -> Compile m a

+ Agda.Compiler.Epic.CompileState: epicError :: String -> Compile TCM a

- Agda.Compiler.Epic.CompileState: getConstrTag :: Monad m => QName -> Compile m Tag

+ Agda.Compiler.Epic.CompileState: getConstrTag :: QName -> Compile TCM Tag

- Agda.Compiler.Epic.CompileState: getDelayed :: MonadTCM m => QName -> Compile m Bool

+ Agda.Compiler.Epic.CompileState: getDelayed :: QName -> Compile TCM Bool

- Agda.Compiler.Epic.CompileState: getMain :: MonadTCM m => Compile m Var

+ Agda.Compiler.Epic.CompileState: getMain :: Compile TCM Var

- Agda.Compiler.Epic.CompileState: newName :: Monad m => Compile m Var

+ Agda.Compiler.Epic.CompileState: newName :: Compile TCM Var

- Agda.Compiler.Epic.CompileState: putDelayed :: Monad m => QName -> Bool -> Compile m ()

+ Agda.Compiler.Epic.CompileState: putDelayed :: QName -> Bool -> Compile TCM ()

- Agda.Compiler.Epic.CompileState: putMain :: Monad m => QName -> Compile m ()

+ Agda.Compiler.Epic.CompileState: putMain :: QName -> Compile TCM ()

- Agda.Compiler.Epic.CompileState: topBindings :: Monad m => Compile m (Set Var)

+ Agda.Compiler.Epic.CompileState: topBindings :: Compile TCM (Set Var)

- Agda.Compiler.Epic.Epic: prettyEpicFun :: Fun -> String

+ Agda.Compiler.Epic.Epic: prettyEpicFun :: MonadTCM m => Fun -> Compile m String

- Agda.Compiler.Epic.Erasure: (&&-) :: Relevancy -> Relevancy -> Relevancy

+ Agda.Compiler.Epic.Erasure: (&&-) :: Relevance -> Relevance -> Relevance

- Agda.Compiler.Epic.Erasure: ErasureState :: Map Var [Relevancy] -> Map Var Fun -> ErasureState

+ Agda.Compiler.Epic.Erasure: ErasureState :: Map Var [Relevance] -> Map Var Fun -> ErasureState

- Agda.Compiler.Epic.Erasure: erasure :: MonadTCM m => [Fun] -> Compile m [Fun]

+ Agda.Compiler.Epic.Erasure: erasure :: [Fun] -> Compile TCM [Fun]

- Agda.Compiler.Epic.Erasure: initiate :: Monad m => Fun -> Erasure m ()

+ Agda.Compiler.Epic.Erasure: initiate :: Fun -> Erasure (Compile TCM) ()

- Agda.Compiler.Epic.Erasure: isIrr :: Relevancy -> Bool

+ Agda.Compiler.Epic.Erasure: isIrr :: Relevance -> Bool

- Agda.Compiler.Epic.Erasure: isRel :: Relevancy -> Bool

+ Agda.Compiler.Epic.Erasure: isRel :: Relevance -> Bool

- Agda.Compiler.Epic.Erasure: relevancies :: ErasureState -> Map Var [Relevancy]

+ Agda.Compiler.Epic.Erasure: relevancies :: ErasureState -> Map Var [Relevance]

- Agda.Compiler.Epic.Erasure: relevant :: (Functor m, Monad m) => Var -> Expr -> Erasure m Relevancy

+ Agda.Compiler.Epic.Erasure: relevant :: (Functor m, Monad m) => Var -> Expr -> Erasure m Relevance

- Agda.Compiler.Epic.Erasure: step :: (Monad m, Functor m) => Erasure m (Map Var [Relevancy])

+ Agda.Compiler.Epic.Erasure: step :: Integer -> Erasure (Compile TCM) (Map Var [Relevance])

- Agda.Compiler.Epic.Forcing: dataParameters :: MonadTCM m => QName -> Compile m Nat

+ Agda.Compiler.Epic.Forcing: dataParameters :: QName -> Compile TCM Nat

- Agda.Compiler.Epic.Forcing: findPosition :: Nat -> [Maybe Term] -> (Nat, Term)

+ Agda.Compiler.Epic.Forcing: findPosition :: Nat -> [Maybe Term] -> Compile TCM (Maybe (Nat, Term))

- Agda.Compiler.Epic.Forcing: insertTele :: MonadTCM m => Int -> Maybe Type -> Term -> Telescope -> Compile m (Telescope, (Type, Type))

+ Agda.Compiler.Epic.Forcing: insertTele :: (QName, Args) -> Int -> Maybe Type -> Term -> Telescope -> Compile TCM (Telescope, (Telescope, Type, Type))

- Agda.Compiler.Epic.Forcing: remForced :: MonadTCM m => CompiledClauses -> Telescope -> Compile m CompiledClauses

+ Agda.Compiler.Epic.Forcing: remForced :: [Fun] -> Compile TCM [Fun]

- Agda.Compiler.Epic.Forcing: replaceForced :: MonadTCM m => (Nat, Telescope) -> [Nat] -> (CompiledClauses, [Maybe Term]) -> Compile m CompiledClauses

+ Agda.Compiler.Epic.Forcing: replaceForced :: ([Var], [Var]) -> Telescope -> [Var] -> [Maybe Term] -> Expr -> Compile TCM Expr

- Agda.Compiler.Epic.Forcing: unifyI :: MonadTCM m => Telescope -> [Nat] -> Type -> Args -> Args -> Compile m [Maybe Term]

+ Agda.Compiler.Epic.Forcing: unifyI :: Telescope -> [Nat] -> Type -> Args -> Args -> Compile TCM [Maybe Term]

- Agda.Compiler.Epic.FromAgda: compileClauses :: MonadTCM m => QName -> Int -> CompiledClauses -> Compile m Fun

+ Agda.Compiler.Epic.FromAgda: compileClauses :: QName -> Int -> CompiledClauses -> Compile TCM Fun

- Agda.Compiler.Epic.FromAgda: fromAgda :: MonadTCM m => Maybe Term -> [(QName, Definition)] -> Compile m [Fun]

+ Agda.Compiler.Epic.FromAgda: fromAgda :: Maybe Term -> [(QName, Definition)] -> Compile TCM [Fun]

- Agda.Compiler.Epic.FromAgda: reverseCCBody :: CompiledClauses -> CompiledClauses

+ Agda.Compiler.Epic.FromAgda: reverseCCBody :: Int -> CompiledClauses -> CompiledClauses

- Agda.Compiler.Epic.FromAgda: substLit :: MonadTCM m => Literal -> Compile m Lit

+ Agda.Compiler.Epic.FromAgda: substLit :: Literal -> Compile TCM Lit

- Agda.Compiler.Epic.FromAgda: substTerm :: MonadTCM m => [Var] -> Term -> Compile m Expr

+ Agda.Compiler.Epic.FromAgda: substTerm :: [Var] -> Term -> Compile TCM Expr

- Agda.Compiler.Epic.FromAgda: translateDefn :: MonadTCM m => Maybe Term -> (QName, Definition) -> Compile m (Maybe Fun)

+ Agda.Compiler.Epic.FromAgda: translateDefn :: Maybe Term -> (QName, Definition) -> Compile TCM (Maybe Fun)

- Agda.Compiler.Epic.NatDetection: getNatish :: MonadTCM m => Compile m [(IrrFilter, [QName])]

+ Agda.Compiler.Epic.NatDetection: getNatish :: Compile TCM [(ForcedArgs, [QName])]

- Agda.Compiler.Epic.NatDetection: nrRel :: IrrFilter -> Integer

+ Agda.Compiler.Epic.NatDetection: nrRel :: ForcedArgs -> Integer

- Agda.Compiler.Epic.Primitive: getBuiltins :: MonadTCM m => Compile m [PrimTransform]

+ Agda.Compiler.Epic.Primitive: getBuiltins :: Compile TCM [PrimTransform]

- Agda.Compiler.Epic.Primitive: natPrimTF :: IrrFilter -> [QName] -> PrimTransform

+ Agda.Compiler.Epic.Primitive: natPrimTF :: ForcedArgs -> [QName] -> PrimTransform

- Agda.Compiler.Epic.Primitive: primExpr :: MonadTCM m => [PrimTransform] -> Expr -> Compile m Expr

+ Agda.Compiler.Epic.Primitive: primExpr :: [PrimTransform] -> Expr -> Compile TCM Expr

- Agda.Compiler.Epic.Primitive: primFun :: MonadTCM m => [PrimTransform] -> Fun -> Compile m Fun

+ Agda.Compiler.Epic.Primitive: primFun :: [PrimTransform] -> Fun -> Compile TCM Fun

- Agda.Compiler.Epic.Primitive: primitivise :: MonadTCM m => [Fun] -> Compile m [Fun]

+ Agda.Compiler.Epic.Primitive: primitivise :: [Fun] -> Compile TCM [Fun]

- Agda.Compiler.HaskellTypes: getHsType :: MonadTCM tcm => QName -> tcm HaskellType

+ Agda.Compiler.HaskellTypes: getHsType :: QName -> TCM HaskellType

- Agda.Compiler.HaskellTypes: getHsVar :: MonadTCM tcm => Nat -> tcm HaskellCode

+ Agda.Compiler.HaskellTypes: getHsVar :: Nat -> TCM HaskellCode

- Agda.Compiler.HaskellTypes: haskellKind :: MonadTCM tcm => Type -> tcm HaskellKind

+ Agda.Compiler.HaskellTypes: haskellKind :: Type -> TCM HaskellKind

- Agda.Compiler.HaskellTypes: haskellType :: MonadTCM tcm => Type -> tcm HaskellType

+ Agda.Compiler.HaskellTypes: haskellType :: Type -> TCM HaskellType

- Agda.Compiler.HaskellTypes: notAHaskellKind :: MonadTCM tcm => Type -> tcm a

+ Agda.Compiler.HaskellTypes: notAHaskellKind :: Type -> TCM a

- Agda.Compiler.HaskellTypes: notAHaskellType :: MonadTCM tcm => Type -> tcm a

+ Agda.Compiler.HaskellTypes: notAHaskellType :: Type -> TCM a

- Agda.Interaction.BasicOps: Assign :: b -> a -> OutputForm a b

+ Agda.Interaction.BasicOps: Assign :: b -> a -> OutputConstraint a b

- Agda.Interaction.BasicOps: CmpInType :: Comparison -> a -> b -> b -> OutputForm a b

+ Agda.Interaction.BasicOps: CmpInType :: Comparison -> a -> b -> b -> OutputConstraint a b

- Agda.Interaction.BasicOps: CmpLevels :: Comparison -> b -> b -> OutputForm a b

+ Agda.Interaction.BasicOps: CmpLevels :: Comparison -> b -> b -> OutputConstraint a b

- Agda.Interaction.BasicOps: CmpSorts :: Comparison -> b -> b -> OutputForm a b

+ Agda.Interaction.BasicOps: CmpSorts :: Comparison -> b -> b -> OutputConstraint a b

- Agda.Interaction.BasicOps: CmpTeles :: Comparison -> b -> b -> OutputForm a b

+ Agda.Interaction.BasicOps: CmpTeles :: Comparison -> b -> b -> OutputConstraint a b

- Agda.Interaction.BasicOps: CmpTypes :: Comparison -> b -> b -> OutputForm a b

+ Agda.Interaction.BasicOps: CmpTypes :: Comparison -> b -> b -> OutputConstraint a b

- Agda.Interaction.BasicOps: Guard :: (OutputForm a b) -> [OutputForm a b] -> OutputForm a b

+ Agda.Interaction.BasicOps: Guard :: (OutputConstraint a b) -> ProblemId -> OutputConstraint a b

- Agda.Interaction.BasicOps: IsEmptyType :: a -> OutputForm a b

+ Agda.Interaction.BasicOps: IsEmptyType :: a -> OutputConstraint a b

- Agda.Interaction.BasicOps: JustSort :: b -> OutputForm a b

+ Agda.Interaction.BasicOps: JustSort :: b -> OutputConstraint a b

- Agda.Interaction.BasicOps: JustType :: b -> OutputForm a b

+ Agda.Interaction.BasicOps: JustType :: b -> OutputConstraint a b

- Agda.Interaction.BasicOps: OfType :: b -> a -> OutputForm a b

+ Agda.Interaction.BasicOps: OfType :: b -> a -> OutputConstraint a b

- Agda.Interaction.BasicOps: OfType' :: b -> a -> OutputForm' a b

+ Agda.Interaction.BasicOps: OfType' :: b -> a -> OutputConstraint' a b

- Agda.Interaction.BasicOps: TypedAssign :: b -> a -> a -> OutputForm a b

+ Agda.Interaction.BasicOps: TypedAssign :: b -> a -> a -> OutputConstraint a b

- Agda.Interaction.BasicOps: contextOfMeta :: InteractionId -> Rewrite -> TCM [OutputForm' Expr Name]

+ Agda.Interaction.BasicOps: contextOfMeta :: InteractionId -> Rewrite -> TCM [OutputConstraint' Expr Name]

- Agda.Interaction.BasicOps: judgToOutputForm :: Judgement a c -> OutputForm a c

+ Agda.Interaction.BasicOps: judgToOutputForm :: Judgement a c -> OutputConstraint a c

- Agda.Interaction.BasicOps: ofExpr :: OutputForm' a b -> a

+ Agda.Interaction.BasicOps: ofExpr :: OutputConstraint' a b -> a

- Agda.Interaction.BasicOps: ofName :: OutputForm' a b -> b

+ Agda.Interaction.BasicOps: ofName :: OutputConstraint' a b -> b

- Agda.Interaction.BasicOps: typeOfMeta :: Rewrite -> InteractionId -> TCM (OutputForm Expr InteractionId)

+ Agda.Interaction.BasicOps: typeOfMeta :: Rewrite -> InteractionId -> TCM (OutputConstraint Expr InteractionId)

- Agda.Interaction.BasicOps: typeOfMetaMI :: Rewrite -> MetaId -> TCM (OutputForm Expr MetaId)

+ Agda.Interaction.BasicOps: typeOfMetaMI :: Rewrite -> MetaId -> TCM (OutputConstraint Expr MetaId)

- Agda.Interaction.BasicOps: typesOfHiddenMetas :: Rewrite -> TCM [OutputForm Expr MetaId]

+ Agda.Interaction.BasicOps: typesOfHiddenMetas :: Rewrite -> TCM [OutputConstraint Expr MetaId]

- Agda.Interaction.BasicOps: typesOfVisibleMetas :: Rewrite -> TCM [OutputForm Expr InteractionId]

+ Agda.Interaction.BasicOps: typesOfVisibleMetas :: Rewrite -> TCM [OutputConstraint Expr InteractionId]

- Agda.Interaction.Highlighting.Generate: generateSyntaxInfo :: AbsolutePath -> Maybe TCErr -> TopLevelInfo -> [([QName], [Range])] -> TCM HighlightingInfo

+ Agda.Interaction.Highlighting.Generate: generateSyntaxInfo :: AbsolutePath -> Maybe TCErr -> TopLevelInfo -> [TerminationError] -> TCM HighlightingInfo

- Agda.Interaction.Imports: Warnings :: [([QName], [Range])] -> [Range] -> Constraints -> Warnings

+ Agda.Interaction.Imports: Warnings :: [TerminationError] -> [Range] -> Constraints -> Warnings

- Agda.Interaction.Imports: terminationProblems :: Warnings -> [([QName], [Range])]

+ Agda.Interaction.Imports: terminationProblems :: Warnings -> [TerminationError]

- Agda.Interaction.MakeCase: findClause :: MetaId -> TCM (QName, Clause)

+ Agda.Interaction.MakeCase: findClause :: MetaId -> TCM (CaseContext, QName, Clause)

- Agda.Interaction.MakeCase: makeCase :: InteractionId -> Range -> String -> TCM [Clause]

+ Agda.Interaction.MakeCase: makeCase :: InteractionId -> Range -> String -> TCM (CaseContext, [Clause])

- Agda.Interaction.Options: Options :: String -> Maybe FilePath -> Either [FilePath] [AbsolutePath] -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Maybe FilePath -> Bool -> Bool -> FilePath -> Maybe FilePath -> Bool -> Bool -> [String] -> PragmaOptions -> [String] -> CommandLineOptions

+ Agda.Interaction.Options: Options :: String -> Maybe FilePath -> Either [FilePath] [AbsolutePath] -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Maybe FilePath -> Bool -> Bool -> Maybe FilePath -> FilePath -> Maybe FilePath -> Bool -> Bool -> [String] -> PragmaOptions -> [String] -> Bool -> CommandLineOptions

- Agda.Syntax.Abstract: Apply :: ModuleInfo -> ModuleName -> [TypedBindings] -> ModuleName -> [NamedArg Expr] -> (Map QName QName) -> (Map ModuleName ModuleName) -> Declaration

+ Agda.Syntax.Abstract: Apply :: ModuleInfo -> ModuleName -> ModuleApplication -> (Map QName QName) -> (Map ModuleName ModuleName) -> Declaration

- Agda.Syntax.Abstract: DataDef :: DefInfo -> QName -> [LamBinding] -> [Constructor] -> Definition

+ Agda.Syntax.Abstract: DataDef :: DefInfo -> QName -> [LamBinding] -> [Constructor] -> Declaration

- Agda.Syntax.Abstract: DomainFree :: Hiding -> Name -> LamBinding

+ Agda.Syntax.Abstract: DomainFree :: Hiding -> Relevance -> Name -> LamBinding

- Agda.Syntax.Abstract: DontCare :: Expr

+ Agda.Syntax.Abstract: DontCare :: Expr -> Expr

- Agda.Syntax.Abstract: FunDef :: DefInfo -> QName -> [Clause] -> Definition

+ Agda.Syntax.Abstract: FunDef :: DefInfo -> QName -> [Clause] -> Declaration

- Agda.Syntax.Abstract: LetApply :: ModuleInfo -> ModuleName -> [TypedBindings] -> ModuleName -> [NamedArg Expr] -> (Map QName QName) -> (Map ModuleName ModuleName) -> LetBinding

+ Agda.Syntax.Abstract: LetApply :: ModuleInfo -> ModuleName -> ModuleApplication -> (Map QName QName) -> (Map ModuleName ModuleName) -> LetBinding

- Agda.Syntax.Abstract: RecDef :: DefInfo -> QName -> (Maybe Constructor) -> [LamBinding] -> Expr -> [Declaration] -> Definition

+ Agda.Syntax.Abstract: RecDef :: DefInfo -> QName -> (Maybe QName) -> [LamBinding] -> Expr -> [Declaration] -> Declaration

- Agda.Syntax.Abstract: TypedBindings :: Range -> (Arg [TypedBinding]) -> TypedBindings

+ Agda.Syntax.Abstract: TypedBindings :: Range -> (Arg TypedBinding) -> TypedBindings

- Agda.Syntax.Abstract.Pretty: prettyA :: (Pretty c, ToConcrete a c, MonadTCM tcm) => a -> tcm Doc

+ Agda.Syntax.Abstract.Pretty: prettyA :: (Pretty c, ToConcrete a c) => a -> TCM Doc

- Agda.Syntax.Abstract.Pretty: prettyATop :: (Pretty c, ToConcrete a c, MonadTCM tcm) => a -> tcm Doc

+ Agda.Syntax.Abstract.Pretty: prettyATop :: (Pretty c, ToConcrete a c) => a -> TCM Doc

- Agda.Syntax.Abstract.Pretty: showA :: (Show c, ToConcrete a c, MonadTCM tcm) => a -> tcm String

+ Agda.Syntax.Abstract.Pretty: showA :: (Show c, ToConcrete a c) => a -> TCM String

- Agda.Syntax.Abstract.Pretty: showATop :: (Show c, ToConcrete a c, MonadTCM tcm) => a -> tcm String

+ Agda.Syntax.Abstract.Pretty: showATop :: (Show c, ToConcrete a c) => a -> TCM String

- Agda.Syntax.Abstract.Views: Application :: Head -> [NamedArg Expr] -> AppView

+ Agda.Syntax.Abstract.Views: Application :: Expr -> [NamedArg Expr] -> AppView

- Agda.Syntax.Concrete: Data :: !Range -> Induction -> Name -> [TypedBindings] -> Expr -> [Constructor] -> Declaration

+ Agda.Syntax.Concrete: Data :: !Range -> Induction -> Name -> [LamBinding] -> (Maybe Expr) -> [Constructor] -> Declaration

- Agda.Syntax.Concrete: DomainFree :: Hiding -> BoundName -> LamBinding

+ Agda.Syntax.Concrete: DomainFree :: Hiding -> Relevance -> BoundName -> LamBinding

- Agda.Syntax.Concrete: ModuleMacro :: !Range -> Name -> [TypedBindings] -> Expr -> OpenShortHand -> ImportDirective -> Declaration

+ Agda.Syntax.Concrete: ModuleMacro :: !Range -> Name -> ModuleApplication -> OpenShortHand -> ImportDirective -> Declaration

- Agda.Syntax.Concrete: OpApp :: !Range -> Name -> [Expr] -> Expr

+ Agda.Syntax.Concrete: OpApp :: !Range -> Name -> [OpApp Expr] -> Expr

- Agda.Syntax.Concrete: Record :: !Range -> Name -> (Maybe Name) -> [TypedBindings] -> Expr -> [Declaration] -> Declaration

+ Agda.Syntax.Concrete: Record :: !Range -> Name -> (Maybe Name) -> [LamBinding] -> (Maybe Expr) -> [Declaration] -> Declaration

- Agda.Syntax.Concrete: TypedBindings :: !Range -> (Arg [TypedBinding]) -> TypedBindings

+ Agda.Syntax.Concrete: TypedBindings :: !Range -> (Arg TypedBinding) -> TypedBindings

- Agda.Syntax.Concrete.Definitions: Axiom :: Range -> Fixity' -> Access -> IsAbstract -> Relevance -> Name -> Expr -> NiceDeclaration

+ Agda.Syntax.Concrete.Definitions: Axiom :: Range -> Fixity' -> Access -> Relevance -> Name -> Expr -> NiceDeclaration

- Agda.Syntax.Concrete.Definitions: DataDef :: Range -> Fixity' -> Access -> IsAbstract -> Name -> [LamBinding] -> [NiceConstructor] -> NiceDefinition

+ Agda.Syntax.Concrete.Definitions: DataDef :: Range -> Fixity' -> IsAbstract -> Name -> [LamBinding] -> [NiceConstructor] -> NiceDeclaration

- Agda.Syntax.Concrete.Definitions: FunDef :: Range -> [Declaration] -> Fixity' -> Access -> IsAbstract -> Name -> [Clause] -> NiceDefinition

+ Agda.Syntax.Concrete.Definitions: FunDef :: Range -> [Declaration] -> Fixity' -> IsAbstract -> Name -> [Clause] -> NiceDeclaration

- Agda.Syntax.Concrete.Definitions: NiceModuleMacro :: Range -> Access -> IsAbstract -> Name -> Telescope -> Expr -> OpenShortHand -> ImportDirective -> NiceDeclaration

+ Agda.Syntax.Concrete.Definitions: NiceModuleMacro :: Range -> Access -> IsAbstract -> Name -> ModuleApplication -> OpenShortHand -> ImportDirective -> NiceDeclaration

- Agda.Syntax.Concrete.Definitions: RecDef :: Range -> Fixity' -> Access -> IsAbstract -> Name -> (Maybe NiceConstructor) -> [LamBinding] -> [NiceDeclaration] -> NiceDefinition

+ Agda.Syntax.Concrete.Definitions: RecDef :: Range -> Fixity' -> IsAbstract -> Name -> (Maybe (ThingWithFixity Name)) -> [LamBinding] -> [NiceDeclaration] -> NiceDeclaration

- Agda.Syntax.Concrete.Definitions: type Nice = Either DeclarationException

+ Agda.Syntax.Concrete.Definitions: type Nice = StateT NiceEnv (Either DeclarationException)

- Agda.Syntax.Concrete.Operators.Parser: OpAppV :: Name -> [e] -> ExprView e

+ Agda.Syntax.Concrete.Operators.Parser: OpAppV :: Name -> [OpApp e] -> ExprView e

- Agda.Syntax.Concrete.Operators.Parser: rebuild :: IsExpr e => NewNotation -> Range -> [e] -> ReadP a e

+ Agda.Syntax.Concrete.Operators.Parser: rebuild :: IsExpr e => NewNotation -> Range -> [e] -> ReadP symbol e

- Agda.Syntax.Internal: DontCare :: Term

+ Agda.Syntax.Internal: DontCare :: Term -> Term

- Agda.Syntax.Internal: Type :: Term -> Sort

+ Agda.Syntax.Internal: Type :: Level -> Sort

- Agda.Syntax.Position: killRange2 :: (KillRange a1, KillRange a) => (a1 -> a -> t) -> a1 -> a -> t

+ Agda.Syntax.Position: killRange2 :: (KillRange a, KillRange a1) => (a1 -> a -> t) -> a1 -> a -> t

- Agda.Syntax.Position: killRange3 :: (KillRange a2, KillRange a1, KillRange a) => (a2 -> a1 -> a -> t) -> a2 -> a1 -> a -> t

+ Agda.Syntax.Position: killRange3 :: (KillRange a, KillRange a1, KillRange a2) => (a2 -> a1 -> a -> t) -> a2 -> a1 -> a -> t

- Agda.Syntax.Position: killRange4 :: (KillRange a3, KillRange a1, KillRange a2, KillRange a) => (a3 -> a2 -> a1 -> a -> t) -> a3 -> a2 -> a1 -> a -> t

+ Agda.Syntax.Position: killRange4 :: (KillRange a, KillRange a1, KillRange a2, KillRange a3) => (a3 -> a2 -> a1 -> a -> t) -> a3 -> a2 -> a1 -> a -> t

- Agda.Syntax.Position: killRange5 :: (KillRange a4, KillRange a2, KillRange a3, KillRange a1, KillRange a) => (a4 -> a3 -> a2 -> a1 -> a -> t) -> a4 -> a3 -> a2 -> a1 -> a -> t

+ Agda.Syntax.Position: killRange5 :: (KillRange a, KillRange a1, KillRange a2, KillRange a3, KillRange a4) => (a4 -> a3 -> a2 -> a1 -> a -> t) -> a4 -> a3 -> a2 -> a1 -> a -> t

- Agda.Syntax.Position: killRange6 :: (KillRange a5, KillRange a1, KillRange a2, KillRange a4, KillRange a3, KillRange a) => (a5 -> a4 -> a3 -> a2 -> a1 -> a -> t) -> a5 -> a4 -> a3 -> a2 -> a1 -> a -> t

+ Agda.Syntax.Position: killRange6 :: (KillRange a, KillRange a1, KillRange a2, KillRange a3, KillRange a4, KillRange a5) => (a5 -> a4 -> a3 -> a2 -> a1 -> a -> t) -> a5 -> a4 -> a3 -> a2 -> a1 -> a -> t

- Agda.Syntax.Position: killRange7 :: (KillRange a6, KillRange a3, KillRange a2, KillRange a5, KillRange a1, KillRange a4, KillRange a) => (a6 -> a5 -> a4 -> a3 -> a2 -> a1 -> a -> t) -> a6 -> a5 -> a4 -> a3 -> a2 -> a1 -> a -> t

+ Agda.Syntax.Position: killRange7 :: (KillRange a, KillRange a1, KillRange a2, KillRange a3, KillRange a4, KillRange a5, KillRange a6) => (a6 -> a5 -> a4 -> a3 -> a2 -> a1 -> a -> t) -> a6 -> a5 -> a4 -> a3 -> a2 -> a1 -> a -> t

- Agda.Syntax.Scope.Base: Scope :: ModuleName -> [ModuleName] -> NameSpace -> NameSpace -> NameSpace -> Map QName ModuleName -> Scope

+ Agda.Syntax.Scope.Base: Scope :: ModuleName -> [ModuleName] -> [(NameSpaceId, NameSpace)] -> Map QName ModuleName -> Scope

- Agda.Syntax.Scope.Base: mapScopeM :: Monad m => (NameSpaceId -> NamesInScope -> m NamesInScope) -> (NameSpaceId -> ModulesInScope -> m ModulesInScope) -> Scope -> m Scope

+ Agda.Syntax.Scope.Base: mapScopeM :: (Functor m, Monad m) => (NameSpaceId -> NamesInScope -> m NamesInScope) -> (NameSpaceId -> ModulesInScope -> m ModulesInScope) -> Scope -> m Scope

- Agda.Syntax.Scope.Base: mapScopeM_ :: Monad m => (NamesInScope -> m NamesInScope) -> (ModulesInScope -> m ModulesInScope) -> Scope -> m Scope

+ Agda.Syntax.Scope.Base: mapScopeM_ :: (Functor m, Monad m) => (NamesInScope -> m NamesInScope) -> (ModulesInScope -> m ModulesInScope) -> Scope -> m Scope

- Agda.Syntax.Scope.Base: mergeNames :: InScope a => ThingsInScope a -> ThingsInScope a -> ThingsInScope a

+ Agda.Syntax.Scope.Base: mergeNames :: Eq a => ThingsInScope a -> ThingsInScope a -> ThingsInScope a

- Agda.Syntax.Scope.Base: namesInScope :: InScope a => [Scope -> NameSpace] -> Scope -> ThingsInScope a

+ Agda.Syntax.Scope.Base: namesInScope :: InScope a => [NameSpaceId] -> Scope -> ThingsInScope a

- Agda.Syntax.Scope.Base: thingsInScope :: [Scope -> NameSpace] -> Scope -> NameSpace

+ Agda.Syntax.Scope.Base: thingsInScope :: [NameSpaceId] -> Scope -> NameSpace

- Agda.Syntax.Scope.Monad: DefinedName :: AbstractName -> ResolvedName

+ Agda.Syntax.Scope.Monad: DefinedName :: Access -> AbstractName -> ResolvedName

- Agda.Syntax.Translation.AbstractToConcrete: abstractToConcreteCtx :: (MonadTCM tcm, ToConcrete a c) => Precedence -> a -> tcm c

+ Agda.Syntax.Translation.AbstractToConcrete: abstractToConcreteCtx :: ToConcrete a c => Precedence -> a -> TCM c

- Agda.Syntax.Translation.AbstractToConcrete: abstractToConcrete_ :: (MonadTCM tcm, ToConcrete a c) => a -> tcm c

+ Agda.Syntax.Translation.AbstractToConcrete: abstractToConcrete_ :: ToConcrete a c => a -> TCM c

- Agda.Syntax.Translation.AbstractToConcrete: runAbsToCon :: MonadTCM tcm => AbsToCon a -> tcm a

+ Agda.Syntax.Translation.AbstractToConcrete: runAbsToCon :: AbsToCon a -> TCM a

- Agda.Syntax.Translation.InternalToAbstract: apps :: MonadTCM tcm => (Expr, [Arg Expr]) -> tcm Expr

+ Agda.Syntax.Translation.InternalToAbstract: apps :: (Expr, [Arg Expr]) -> TCM Expr

- Agda.Syntax.Translation.InternalToAbstract: reify :: (Reify i a, MonadTCM tcm) => i -> tcm a

+ Agda.Syntax.Translation.InternalToAbstract: reify :: Reify i a => i -> TCM a

- Agda.Syntax.Translation.InternalToAbstract: reifyApp :: MonadTCM tcm => Expr -> [Arg Term] -> tcm Expr

+ Agda.Syntax.Translation.InternalToAbstract: reifyApp :: Expr -> [Arg Term] -> TCM Expr

- Agda.Syntax.Translation.InternalToAbstract: reifyDisplayForm :: MonadTCM tcm => QName -> Args -> tcm Expr -> tcm Expr

+ Agda.Syntax.Translation.InternalToAbstract: reifyDisplayForm :: QName -> Args -> TCM Expr -> TCM Expr

- Agda.Syntax.Translation.InternalToAbstract: reifyPatterns :: MonadTCM tcm => Telescope -> Permutation -> [Arg Pattern] -> tcm [NamedArg Pattern]

+ Agda.Syntax.Translation.InternalToAbstract: reifyPatterns :: Telescope -> Permutation -> [Arg Pattern] -> TCM [NamedArg Pattern]

- Agda.Syntax.Translation.InternalToAbstract: stripImplicits :: MonadTCM tcm => [NamedArg Pattern] -> [Pattern] -> tcm ([NamedArg Pattern], [Pattern])

+ Agda.Syntax.Translation.InternalToAbstract: stripImplicits :: [NamedArg Pattern] -> [Pattern] -> TCM ([NamedArg Pattern], [Pattern])

- Agda.Termination.SparseMatrix: diagonal :: (Enum i, Num i, Ix i, HasZero b) => Matrix i b -> Array i b

+ Agda.Termination.SparseMatrix: diagonal :: (Show i, Enum i, Num i, Ix i, HasZero b) => Matrix i b -> Array i b

- Agda.Termination.SparseMatrix: toLists :: (Ord i, Integral i, Enum i, HasZero b) => Matrix i b -> [[b]]

+ Agda.Termination.SparseMatrix: toLists :: (Show i, Ord i, Integral i, Enum i, HasZero b) => Matrix i b -> [[b]]

- Agda.Termination.TermCheck: type Result = [([QName], [Range])]

+ Agda.Termination.TermCheck: type Result = [TerminationError]

- Agda.TypeChecking.CompiledClause: Done :: Int -> Term -> CompiledClauses

+ Agda.TypeChecking.CompiledClause: Done :: [Arg String] -> Term -> CompiledClauses

- Agda.TypeChecking.Constraints: catchConstraint :: MonadTCM tcm => Constraint -> TCM Constraints -> tcm Constraints

+ Agda.TypeChecking.Constraints: catchConstraint :: Constraint -> TCM () -> TCM ()

- Agda.TypeChecking.Constraints: guardConstraint :: MonadTCM tcm => tcm Constraints -> Constraint -> tcm Constraints

+ Agda.TypeChecking.Constraints: guardConstraint :: Constraint -> TCM () -> TCM ()

- Agda.TypeChecking.Constraints: noConstraints :: MonadTCM tcm => tcm Constraints -> tcm ()

+ Agda.TypeChecking.Constraints: noConstraints :: TCM a -> TCM a

- Agda.TypeChecking.Constraints: solveConstraint :: MonadTCM tcm => Constraint -> tcm Constraints

+ Agda.TypeChecking.Constraints: solveConstraint :: Constraint -> TCM ()

- Agda.TypeChecking.Constraints: wakeupConstraints :: MonadTCM tcm => tcm ()

+ Agda.TypeChecking.Constraints: wakeupConstraints :: MetaId -> TCM ()

- Agda.TypeChecking.Conversion: compareArgs :: MonadTCM tcm => [Polarity] -> Type -> Args -> Args -> tcm Constraints

+ Agda.TypeChecking.Conversion: compareArgs :: [Polarity] -> Type -> Term -> Args -> Args -> TCM ()

- Agda.TypeChecking.Conversion: compareAtom :: MonadTCM tcm => Comparison -> Type -> Term -> Term -> tcm Constraints

+ Agda.TypeChecking.Conversion: compareAtom :: Comparison -> Type -> Term -> Term -> TCM ()

- Agda.TypeChecking.Conversion: compareSort :: MonadTCM tcm => Comparison -> Sort -> Sort -> tcm Constraints

+ Agda.TypeChecking.Conversion: compareSort :: Comparison -> Sort -> Sort -> TCM ()

- Agda.TypeChecking.Conversion: compareTel :: MonadTCM tcm => Comparison -> Telescope -> Telescope -> tcm Constraints

+ Agda.TypeChecking.Conversion: compareTel :: Type -> Type -> Comparison -> Telescope -> Telescope -> TCM ()

- Agda.TypeChecking.Conversion: compareTerm :: MonadTCM tcm => Comparison -> Type -> Term -> Term -> tcm Constraints

+ Agda.TypeChecking.Conversion: compareTerm :: Comparison -> Type -> Term -> Term -> TCM ()

- Agda.TypeChecking.Conversion: compareType :: MonadTCM tcm => Comparison -> Type -> Type -> tcm Constraints

+ Agda.TypeChecking.Conversion: compareType :: Comparison -> Type -> Type -> TCM ()

- Agda.TypeChecking.Conversion: equalAtom :: MonadTCM tcm => Type -> Term -> Term -> tcm Constraints

+ Agda.TypeChecking.Conversion: equalAtom :: Type -> Term -> Term -> TCM ()

- Agda.TypeChecking.Conversion: equalLevel :: MonadTCM tcm => Term -> Term -> tcm Constraints

+ Agda.TypeChecking.Conversion: equalLevel :: Level -> Level -> TCM ()

- Agda.TypeChecking.Conversion: equalSort :: MonadTCM tcm => Sort -> Sort -> tcm Constraints

+ Agda.TypeChecking.Conversion: equalSort :: Sort -> Sort -> TCM ()

- Agda.TypeChecking.Conversion: equalTerm :: MonadTCM tcm => Type -> Term -> Term -> tcm Constraints

+ Agda.TypeChecking.Conversion: equalTerm :: Type -> Term -> Term -> TCM ()

- Agda.TypeChecking.Conversion: equalType :: MonadTCM tcm => Type -> Type -> tcm Constraints

+ Agda.TypeChecking.Conversion: equalType :: Type -> Type -> TCM ()

- Agda.TypeChecking.Conversion: leqLevel :: MonadTCM tcm => Term -> Term -> tcm Constraints

+ Agda.TypeChecking.Conversion: leqLevel :: Level -> Level -> TCM ()

- Agda.TypeChecking.Conversion: leqSort :: MonadTCM tcm => Sort -> Sort -> tcm Constraints

+ Agda.TypeChecking.Conversion: leqSort :: Sort -> Sort -> TCM ()

- Agda.TypeChecking.Conversion: leqType :: MonadTCM tcm => Type -> Type -> tcm Constraints

+ Agda.TypeChecking.Conversion: leqType :: Type -> Type -> TCM ()

- Agda.TypeChecking.Coverage: cover :: MonadTCM tcm => [Clause] -> SplitClause -> tcm (Set Nat, [[Arg Pattern]])

+ Agda.TypeChecking.Coverage: cover :: [Clause] -> SplitClause -> TCM (Set Nat, [[Arg Pattern]])

- Agda.TypeChecking.Coverage: split :: MonadTCM tcm => Induction -> Telescope -> Permutation -> [Arg Pattern] -> Nat -> tcm (Either SplitError Covering)

+ Agda.TypeChecking.Coverage: split :: Induction -> Telescope -> Permutation -> [Arg Pattern] -> Nat -> TCM (Either SplitError Covering)

- Agda.TypeChecking.Coverage: split' :: MonadTCM tcm => Induction -> Telescope -> Permutation -> [Arg Pattern] -> Nat -> tcm (Either SplitError (Either SplitClause Covering))

+ Agda.TypeChecking.Coverage: split' :: Induction -> Telescope -> Permutation -> [Arg Pattern] -> Nat -> TCM (Either SplitError (Either SplitClause Covering))

- Agda.TypeChecking.Coverage.Match: Block :: (Maybe Nat) -> Match a

+ Agda.TypeChecking.Coverage.Match: Block :: Nat -> Match a

- Agda.TypeChecking.Datatypes: getConstructorData :: MonadTCM tcm => QName -> tcm QName

+ Agda.TypeChecking.Datatypes: getConstructorData :: QName -> TCM QName

- Agda.TypeChecking.Datatypes: getDatatypeInfo :: MonadTCM tcm => Type -> tcm (Maybe DatatypeInfo)

+ Agda.TypeChecking.Datatypes: getDatatypeInfo :: Type -> TCM (Maybe DatatypeInfo)

- Agda.TypeChecking.Datatypes: isDatatype :: MonadTCM tcm => QName -> tcm Bool

+ Agda.TypeChecking.Datatypes: isDatatype :: QName -> TCM Bool

- Agda.TypeChecking.Empty: isEmptyType :: MonadTCM tcm => Type -> tcm ()

+ Agda.TypeChecking.Empty: isEmptyType :: Type -> TCM ()

- Agda.TypeChecking.Errors: prettyError :: MonadTCM tcm => TCErr -> tcm String

+ Agda.TypeChecking.Errors: prettyError :: TCErr -> TCM String

- Agda.TypeChecking.Errors: prettyTCM :: (PrettyTCM a, MonadTCM tcm) => a -> tcm Doc

+ Agda.TypeChecking.Errors: prettyTCM :: PrettyTCM a => a -> TCM Doc

- Agda.TypeChecking.EtaContract: etaContract :: (MonadTCM tcm, TermLike a) => a -> tcm a

+ Agda.TypeChecking.EtaContract: etaContract :: TermLike a => a -> TCM a

- Agda.TypeChecking.EtaContract: etaOnce :: MonadTCM tcm => Term -> tcm Term

+ Agda.TypeChecking.EtaContract: etaOnce :: Term -> TCM Term

- Agda.TypeChecking.Free: FV :: Set Nat -> Set Nat -> FreeVars

+ Agda.TypeChecking.Free: FV :: VarSet -> VarSet -> VarSet -> VarSet -> FreeVars

- Agda.TypeChecking.Free: allVars :: FreeVars -> Set Nat

+ Agda.TypeChecking.Free: allVars :: FreeVars -> VarSet

- Agda.TypeChecking.Free: flexibleVars :: FreeVars -> Set Nat

+ Agda.TypeChecking.Free: flexibleVars :: FreeVars -> VarSet

- Agda.TypeChecking.Free: rigidVars :: FreeVars -> Set Nat

+ Agda.TypeChecking.Free: rigidVars :: FreeVars -> VarSet

- Agda.TypeChecking.Implicit: ImpInsert :: Int -> ImplicitInsertion

+ Agda.TypeChecking.Implicit: ImpInsert :: [Hiding] -> ImplicitInsertion

- Agda.TypeChecking.Implicit: impInsert :: Int -> ImplicitInsertion

+ Agda.TypeChecking.Implicit: impInsert :: [Hiding] -> ImplicitInsertion

- Agda.TypeChecking.Injectivity: useInjectivity :: Comparison -> Type -> Term -> Term -> TCM Constraints

+ Agda.TypeChecking.Injectivity: useInjectivity :: Comparison -> Type -> Term -> Term -> TCM ()

- Agda.TypeChecking.Level: builtinLevelKit :: MonadTCM tcm => tcm (Maybe LevelKit)

+ Agda.TypeChecking.Level: builtinLevelKit :: TCM (Maybe LevelKit)

- Agda.TypeChecking.Level: levelSucFunction :: MonadTCM tcm => tcm (Term -> Term)

+ Agda.TypeChecking.Level: levelSucFunction :: TCM (Term -> Term)

- Agda.TypeChecking.Level: levelView :: MonadTCM tcm => Term -> tcm LevelView

+ Agda.TypeChecking.Level: levelView :: Term -> TCM Level

- Agda.TypeChecking.Level: maybePrimCon :: MonadTCM tcm => TCM Term -> tcm (Maybe QName)

+ Agda.TypeChecking.Level: maybePrimCon :: TCM Term -> TCM (Maybe QName)

- Agda.TypeChecking.Level: maybePrimDef :: MonadTCM tcm => TCM Term -> tcm (Maybe QName)

+ Agda.TypeChecking.Level: maybePrimDef :: TCM Term -> TCM (Maybe QName)

- Agda.TypeChecking.MetaVars: assignTerm :: MonadTCM tcm => MetaId -> Term -> tcm ()

+ Agda.TypeChecking.MetaVars: assignTerm :: MetaId -> Term -> TCM ()

- Agda.TypeChecking.MetaVars: assignV :: MonadTCM tcm => Type -> MetaId -> Args -> Term -> tcm Constraints

+ Agda.TypeChecking.MetaVars: assignV :: MetaId -> Args -> Term -> TCM ()

- Agda.TypeChecking.MetaVars: blockTerm :: MonadTCM tcm => Type -> Term -> tcm Constraints -> tcm Term

+ Agda.TypeChecking.MetaVars: blockTerm :: Type -> TCM Term -> TCM Term

- Agda.TypeChecking.MetaVars: etaExpandBlocked :: (MonadTCM tcm, Reduce t) => Blocked t -> tcm (Blocked t)

+ Agda.TypeChecking.MetaVars: etaExpandBlocked :: Reduce t => Blocked t -> TCM (Blocked t)

- Agda.TypeChecking.MetaVars: etaExpandListeners :: MonadTCM tcm => MetaId -> tcm ()

+ Agda.TypeChecking.MetaVars: etaExpandListeners :: MetaId -> TCM ()

- Agda.TypeChecking.MetaVars: etaExpandMeta :: MonadTCM tcm => [MetaKind] -> MetaId -> tcm ()

+ Agda.TypeChecking.MetaVars: etaExpandMeta :: [MetaKind] -> MetaId -> TCM ()

- Agda.TypeChecking.MetaVars: etaExpandMetaSafe :: MonadTCM tcm => MetaId -> tcm ()

+ Agda.TypeChecking.MetaVars: etaExpandMetaSafe :: MetaId -> TCM ()

- Agda.TypeChecking.MetaVars: isBlockedTerm :: MonadTCM tcm => MetaId -> tcm Bool

+ Agda.TypeChecking.MetaVars: isBlockedTerm :: MetaId -> TCM Bool

- Agda.TypeChecking.MetaVars: isEtaExpandable :: MonadTCM tcm => MetaId -> tcm Bool

+ Agda.TypeChecking.MetaVars: isEtaExpandable :: MetaId -> TCM Bool

- Agda.TypeChecking.MetaVars: newArgsMeta :: MonadTCM tcm => Type -> tcm Args

+ Agda.TypeChecking.MetaVars: newArgsMeta :: Type -> TCM Args

- Agda.TypeChecking.MetaVars: newArgsMetaCtx :: MonadTCM tcm => Type -> Telescope -> Args -> tcm Args

+ Agda.TypeChecking.MetaVars: newArgsMetaCtx :: Type -> Telescope -> Args -> TCM Args

- Agda.TypeChecking.MetaVars: newQuestionMark :: MonadTCM tcm => Type -> tcm Term

+ Agda.TypeChecking.MetaVars: newQuestionMark :: Type -> TCM Term

- Agda.TypeChecking.MetaVars: newRecordMeta :: MonadTCM tcm => QName -> Args -> tcm Term

+ Agda.TypeChecking.MetaVars: newRecordMeta :: QName -> Args -> TCM Term

- Agda.TypeChecking.MetaVars: newRecordMetaCtx :: MonadTCM tcm => QName -> Args -> Telescope -> Args -> tcm Term

+ Agda.TypeChecking.MetaVars: newRecordMetaCtx :: QName -> Args -> Telescope -> Args -> TCM Term

- Agda.TypeChecking.MetaVars: newSortMeta :: MonadTCM tcm => tcm Sort

+ Agda.TypeChecking.MetaVars: newSortMeta :: TCM Sort

- Agda.TypeChecking.MetaVars: newSortMetaCtx :: MonadTCM tcm => Args -> tcm Sort

+ Agda.TypeChecking.MetaVars: newSortMetaCtx :: Args -> TCM Sort

- Agda.TypeChecking.MetaVars: newTelMeta :: MonadTCM tcm => Telescope -> tcm Args

+ Agda.TypeChecking.MetaVars: newTelMeta :: Telescope -> TCM Args

- Agda.TypeChecking.MetaVars: newTypeMeta :: MonadTCM tcm => Sort -> tcm Type

+ Agda.TypeChecking.MetaVars: newTypeMeta :: Sort -> TCM Type

- Agda.TypeChecking.MetaVars: newTypeMeta_ :: MonadTCM tcm => tcm Type

+ Agda.TypeChecking.MetaVars: newTypeMeta_ :: TCM Type

- Agda.TypeChecking.MetaVars: newValueMeta :: MonadTCM tcm => Type -> tcm Term

+ Agda.TypeChecking.MetaVars: newValueMeta :: Type -> TCM Term

- Agda.TypeChecking.MetaVars: newValueMeta' :: MonadTCM tcm => Type -> tcm Term

+ Agda.TypeChecking.MetaVars: newValueMeta' :: Type -> TCM Term

- Agda.TypeChecking.MetaVars: newValueMetaCtx :: MonadTCM tcm => Type -> Args -> tcm Term

+ Agda.TypeChecking.MetaVars: newValueMetaCtx :: Type -> Args -> TCM Term

- Agda.TypeChecking.MetaVars: newValueMetaCtx' :: MonadTCM tcm => Type -> Args -> tcm Term

+ Agda.TypeChecking.MetaVars: newValueMetaCtx' :: Type -> Args -> TCM Term

- Agda.TypeChecking.MetaVars: postponeTypeCheckingProblem :: MonadTCM tcm => Expr -> Type -> TCM Bool -> tcm Term

+ Agda.TypeChecking.MetaVars: postponeTypeCheckingProblem :: Expr -> Type -> TCM Bool -> TCM Term

- Agda.TypeChecking.MetaVars: postponeTypeCheckingProblem_ :: MonadTCM tcm => Expr -> Type -> tcm Term

+ Agda.TypeChecking.MetaVars: postponeTypeCheckingProblem_ :: Expr -> Type -> TCM Term

- Agda.TypeChecking.MetaVars: type FVs = Set Nat

+ Agda.TypeChecking.MetaVars: type FVs = VarSet

- Agda.TypeChecking.MetaVars: unblockedTester :: MonadTCM tcm => Type -> tcm Bool

+ Agda.TypeChecking.MetaVars: unblockedTester :: Type -> TCM Bool

- Agda.TypeChecking.MetaVars: updateMeta :: (MonadTCM tcm, Data a, Occurs a, Abstract a) => MetaId -> a -> tcm ()

+ Agda.TypeChecking.MetaVars: updateMeta :: MetaId -> Term -> TCM ()

- Agda.TypeChecking.MetaVars.Occurs: killArgs :: [Bool] -> MetaId -> TCM Bool

+ Agda.TypeChecking.MetaVars.Occurs: killArgs :: [Bool] -> MetaId -> TCM PruneResult

- Agda.TypeChecking.MetaVars.Occurs: occurs :: Occurs t => OccursCtx -> MetaId -> [Nat] -> t -> TCM t

+ Agda.TypeChecking.MetaVars.Occurs: occurs :: Occurs t => UnfoldStrategy -> OccursCtx -> MetaId -> Vars -> t -> TCM t

- Agda.TypeChecking.MetaVars.Occurs: occursCheck :: MonadTCM tcm => MetaId -> [Nat] -> Term -> tcm Term

+ Agda.TypeChecking.MetaVars.Occurs: occursCheck :: MetaId -> Vars -> Term -> TCM Term

- Agda.TypeChecking.Monad.Base: Axiom :: Maybe HaskellRepresentation -> Maybe EpicCode -> Defn

+ Agda.TypeChecking.Monad.Base: Axiom :: Defn

- Agda.TypeChecking.Monad.Base: CheckArguments :: Range -> [NamedArg Expr] -> Type -> Type -> (Maybe (Args, Type, Constraints)) -> Call

+ Agda.TypeChecking.Monad.Base: CheckArguments :: Range -> [NamedArg Expr] -> Type -> Type -> (Maybe (Args, Type)) -> Call

- Agda.TypeChecking.Monad.Base: CheckSectionApplication :: Range -> ModuleName -> Telescope -> ModuleName -> [NamedArg Expr] -> (Maybe ()) -> Call

+ Agda.TypeChecking.Monad.Base: CheckSectionApplication :: Range -> ModuleName -> ModuleApplication -> (Maybe ()) -> Call

- Agda.TypeChecking.Monad.Base: Constructor :: Nat -> QName -> QName -> Maybe (HaskellType, HaskellCode) -> IsAbstract -> Induction -> Defn

+ Agda.TypeChecking.Monad.Base: Constructor :: Nat -> QName -> QName -> IsAbstract -> Induction -> Defn

- Agda.TypeChecking.Monad.Base: CoverageCantSplitOn :: QName -> TypeError

+ Agda.TypeChecking.Monad.Base: CoverageCantSplitOn :: QName -> Telescope -> Args -> Args -> TypeError

- Agda.TypeChecking.Monad.Base: Datatype :: Nat -> Nat -> Induction -> (Maybe Clause) -> [QName] -> Sort -> [Polarity] -> [Occurrence] -> Maybe HaskellType -> IsAbstract -> Defn

+ Agda.TypeChecking.Monad.Base: Datatype :: Nat -> Nat -> Induction -> (Maybe Clause) -> [QName] -> Sort -> [Polarity] -> [Occurrence] -> IsAbstract -> Defn

- Agda.TypeChecking.Monad.Base: Defn :: Relevance -> QName -> Type -> [Open DisplayForm] -> MutualId -> Defn -> Definition

+ Agda.TypeChecking.Monad.Base: Defn :: Relevance -> QName -> Type -> [Open DisplayForm] -> MutualId -> CompiledRepresentation -> Defn -> Definition

- Agda.TypeChecking.Monad.Base: Fresh :: MetaId -> InteractionId -> MutualId -> NameId -> CtxId -> Integer -> FreshThings

+ Agda.TypeChecking.Monad.Base: Fresh :: MetaId -> InteractionId -> MutualId -> NameId -> CtxId -> ProblemId -> Integer -> FreshThings

- Agda.TypeChecking.Monad.Base: Function :: [Clauses] -> CompiledClauses -> FunctionInverse -> [Polarity] -> [Occurrence] -> IsAbstract -> Delayed -> Maybe Int -> Defn

+ Agda.TypeChecking.Monad.Base: Function :: [Clause] -> CompiledClauses -> FunctionInverse -> [Polarity] -> [Occurrence] -> IsAbstract -> Delayed -> Maybe (QName, Int) -> Bool -> Defn

- Agda.TypeChecking.Monad.Base: Guarded :: Constraint -> Constraints -> Constraint

+ Agda.TypeChecking.Monad.Base: Guarded :: Constraint -> ProblemId -> Constraint

- Agda.TypeChecking.Monad.Base: IsSort :: a -> Judgement t a

+ Agda.TypeChecking.Monad.Base: IsSort :: a -> t -> Judgement t a

- Agda.TypeChecking.Monad.Base: LevelCmp :: Comparison -> Term -> Term -> Constraint

+ Agda.TypeChecking.Monad.Base: LevelCmp :: Comparison -> Level -> Level -> Constraint

- Agda.TypeChecking.Monad.Base: MetaVar :: MetaInfo -> MetaPriority -> Permutation -> Judgement Type MetaId -> MetaInstantiation -> Set MetaId -> MetaVariable

+ Agda.TypeChecking.Monad.Base: MetaVar :: MetaInfo -> MetaPriority -> Permutation -> Judgement Type MetaId -> MetaInstantiation -> Set Listener -> Frozen -> MetaVariable

- Agda.TypeChecking.Monad.Base: PrimFun :: QName -> Arity -> (forall tcm. MonadTCM tcm => [Arg Term] -> tcm (Reduced MaybeReducedArgs Term)) -> PrimFun

+ Agda.TypeChecking.Monad.Base: PrimFun :: QName -> Arity -> ([Arg Term] -> TCM (Reduced MaybeReducedArgs Term)) -> PrimFun

- Agda.TypeChecking.Monad.Base: Primitive :: IsAbstract -> String -> Maybe [Clauses] -> Maybe CompiledClauses -> Defn

+ Agda.TypeChecking.Monad.Base: Primitive :: IsAbstract -> String -> Maybe [Clause] -> Maybe CompiledClauses -> Defn

- Agda.TypeChecking.Monad.Base: TCEnv :: Context -> LetBindings -> ModuleName -> [(ModuleName, Nat)] -> [TopLevelModuleName] -> Maybe MutualId -> AbstractMode -> Bool -> Bool -> Bool -> Bool -> Bool -> Range -> Maybe (Closure Call) -> TCEnv

+ Agda.TypeChecking.Monad.Base: TCEnv :: Context -> LetBindings -> ModuleName -> [(ModuleName, Nat)] -> [TopLevelModuleName] -> Maybe MutualId -> Bool -> [ProblemId] -> AbstractMode -> Bool -> Relevance -> Bool -> Bool -> Bool -> Range -> Maybe (Closure Call) -> TCEnv

- Agda.TypeChecking.Monad.Base: TCM :: (TCState -> TCEnv -> m (a, TCState)) -> TCMT m a

+ Agda.TypeChecking.Monad.Base: TCM :: (IORef TCState -> TCEnv -> m a) -> TCMT m a

- Agda.TypeChecking.Monad.Base: TCSt :: FreshThings -> MetaStore -> InteractionPoints -> Constraints -> Signature -> Signature -> Set ModuleName -> ModuleToSource -> VisitedModules -> DecodedModules -> Maybe ModuleName -> ScopeInfo -> CommandLineOptions -> PragmaOptions -> Statistics -> Map MutualId (Set QName) -> BuiltinThings PrimFun -> BuiltinThings PrimFun -> Set String -> TCState

+ Agda.TypeChecking.Monad.Base: TCSt :: FreshThings -> MetaStore -> InteractionPoints -> Constraints -> Constraints -> Signature -> Signature -> Set ModuleName -> ModuleToSource -> VisitedModules -> Maybe ModuleName -> ScopeInfo -> PragmaOptions -> Statistics -> Map QName (Int, Int) -> Map MutualId (Set QName) -> BuiltinThings PrimFun -> BuiltinThings PrimFun -> Set String -> PersistentTCState -> TCState

- Agda.TypeChecking.Monad.Base: TelCmp :: Comparison -> Telescope -> Telescope -> Constraint

+ Agda.TypeChecking.Monad.Base: TelCmp :: Type -> Type -> Comparison -> Telescope -> Telescope -> Constraint

- Agda.TypeChecking.Monad.Base: TerminationCheckFailed :: [([QName], [Range])] -> TypeError

+ Agda.TypeChecking.Monad.Base: TerminationCheckFailed :: [TerminationError] -> TypeError

- Agda.TypeChecking.Monad.Base: buildClosure :: MonadTCM tcm => a -> tcm (Closure a)

+ Agda.TypeChecking.Monad.Base: buildClosure :: a -> TCM (Closure a)

- Agda.TypeChecking.Monad.Base: defClauses :: Definition -> [Clauses]

+ Agda.TypeChecking.Monad.Base: defClauses :: Definition -> [Clause]

- Agda.TypeChecking.Monad.Base: funClauses :: Defn -> [Clauses]

+ Agda.TypeChecking.Monad.Base: funClauses :: Defn -> [Clause]

- Agda.TypeChecking.Monad.Base: funProjection :: Defn -> Maybe Int

+ Agda.TypeChecking.Monad.Base: funProjection :: Defn -> Maybe (QName, Int)

- Agda.TypeChecking.Monad.Base: mvListeners :: MetaVariable -> Set MetaId

+ Agda.TypeChecking.Monad.Base: mvListeners :: MetaVariable -> Set Listener

- Agda.TypeChecking.Monad.Base: patternViolation :: MonadTCM tcm => tcm a

+ Agda.TypeChecking.Monad.Base: patternViolation :: TCM a

- Agda.TypeChecking.Monad.Base: primClauses :: Defn -> Maybe [Clauses]

+ Agda.TypeChecking.Monad.Base: primClauses :: Defn -> Maybe [Clause]

- Agda.TypeChecking.Monad.Base: primFunImplementation :: PrimFun -> forall tcm. MonadTCM tcm => [Arg Term] -> tcm (Reduced MaybeReducedArgs Term)

+ Agda.TypeChecking.Monad.Base: primFunImplementation :: PrimFun -> [Arg Term] -> TCM (Reduced MaybeReducedArgs Term)

- Agda.TypeChecking.Monad.Base: pureTCM :: Monad m => (TCState -> TCEnv -> a) -> TCMT m a

+ Agda.TypeChecking.Monad.Base: pureTCM :: MonadIO m => (TCState -> TCEnv -> a) -> TCMT m a

- Agda.TypeChecking.Monad.Base: reduced :: Blocked a -> MaybeReduced a

+ Agda.TypeChecking.Monad.Base: reduced :: Blocked (Arg Term) -> MaybeReduced (Arg Term)

- Agda.TypeChecking.Monad.Base: runTCM' :: Monad m => TCMT m a -> m a

+ Agda.TypeChecking.Monad.Base: runTCM' :: MonadIO m => TCMT m a -> m a

- Agda.TypeChecking.Monad.Base: stDecodedModules :: TCState -> DecodedModules

+ Agda.TypeChecking.Monad.Base: stDecodedModules :: PersistentTCState -> DecodedModules

- Agda.TypeChecking.Monad.Base: stPersistentOptions :: TCState -> CommandLineOptions

+ Agda.TypeChecking.Monad.Base: stPersistentOptions :: PersistentTCState -> CommandLineOptions

- Agda.TypeChecking.Monad.Base: type Constraints = [ConstraintClosure]

+ Agda.TypeChecking.Monad.Base: type Constraints = [ProblemConstraint]

- Agda.TypeChecking.Monad.Base: type Statistics = Map String Int

+ Agda.TypeChecking.Monad.Base: type Statistics = Map String Integer

- Agda.TypeChecking.Monad.Base: unTCM :: TCMT m a -> TCState -> TCEnv -> m (a, TCState)

+ Agda.TypeChecking.Monad.Base: unTCM :: TCMT m a -> IORef TCState -> TCEnv -> m a

- Agda.TypeChecking.Monad.Builtin: bindBuiltinName :: MonadTCM tcm => String -> Term -> tcm ()

+ Agda.TypeChecking.Monad.Builtin: bindBuiltinName :: String -> Term -> TCM ()

- Agda.TypeChecking.Monad.Builtin: bindPrimitive :: MonadTCM tcm => String -> PrimFun -> tcm ()

+ Agda.TypeChecking.Monad.Builtin: bindPrimitive :: String -> PrimFun -> TCM ()

- Agda.TypeChecking.Monad.Builtin: getBuiltin :: MonadTCM tcm => String -> tcm Term

+ Agda.TypeChecking.Monad.Builtin: getBuiltin :: String -> TCM Term

- Agda.TypeChecking.Monad.Builtin: getBuiltin' :: MonadTCM tcm => String -> tcm (Maybe Term)

+ Agda.TypeChecking.Monad.Builtin: getBuiltin' :: String -> TCM (Maybe Term)

- Agda.TypeChecking.Monad.Builtin: getPrimitive :: MonadTCM tcm => String -> tcm PrimFun

+ Agda.TypeChecking.Monad.Builtin: getPrimitive :: String -> TCM PrimFun

- Agda.TypeChecking.Monad.Builtin: setBuiltinThings :: MonadTCM tcm => BuiltinThings PrimFun -> tcm ()

+ Agda.TypeChecking.Monad.Builtin: setBuiltinThings :: BuiltinThings PrimFun -> TCM ()

- Agda.TypeChecking.Monad.Closure: enterClosure :: MonadTCM tcm => Closure a -> (a -> tcm b) -> tcm b

+ Agda.TypeChecking.Monad.Closure: enterClosure :: Closure a -> (a -> TCM b) -> TCM b

- Agda.TypeChecking.Monad.Constraints: buildConstraint :: MonadTCM tcm => Constraint -> tcm Constraints

+ Agda.TypeChecking.Monad.Constraints: buildConstraint :: Constraint -> TCM ProblemConstraint

- Agda.TypeChecking.Monad.Constraints: withConstraint :: MonadTCM tcm => (Constraint -> tcm a) -> ConstraintClosure -> tcm a

+ Agda.TypeChecking.Monad.Constraints: withConstraint :: (Constraint -> TCM a) -> ProblemConstraint -> TCM a

- Agda.TypeChecking.Monad.Context: underAbstraction :: MonadTCM tcm => Arg Type -> Abs a -> (a -> tcm b) -> tcm b

+ Agda.TypeChecking.Monad.Context: underAbstraction :: (Raise a, MonadTCM tcm) => Arg Type -> Abs a -> (a -> tcm b) -> tcm b

- Agda.TypeChecking.Monad.Context: underAbstraction_ :: MonadTCM tcm => Abs a -> (a -> tcm b) -> tcm b

+ Agda.TypeChecking.Monad.Context: underAbstraction_ :: (Raise a, MonadTCM tcm) => Abs a -> (a -> tcm b) -> tcm b

- Agda.TypeChecking.Monad.Env: currentModule :: MonadTCM tcm => tcm ModuleName

+ Agda.TypeChecking.Monad.Env: currentModule :: TCM ModuleName

- Agda.TypeChecking.Monad.Env: getAnonymousVariables :: MonadTCM tcm => ModuleName -> tcm Nat

+ Agda.TypeChecking.Monad.Env: getAnonymousVariables :: ModuleName -> TCM Nat

- Agda.TypeChecking.Monad.Env: getEnv :: MonadTCM tcm => tcm TCEnv

+ Agda.TypeChecking.Monad.Env: getEnv :: TCM TCEnv

- Agda.TypeChecking.Monad.Env: withAnonymousModule :: MonadTCM tcm => ModuleName -> Nat -> tcm a -> tcm a

+ Agda.TypeChecking.Monad.Env: withAnonymousModule :: ModuleName -> Nat -> TCM a -> TCM a

- Agda.TypeChecking.Monad.Env: withCurrentModule :: MonadTCM tcm => ModuleName -> tcm a -> tcm a

+ Agda.TypeChecking.Monad.Env: withCurrentModule :: ModuleName -> TCM a -> TCM a

- Agda.TypeChecking.Monad.Env: withEnv :: MonadTCM tcm => TCEnv -> tcm a -> tcm a

+ Agda.TypeChecking.Monad.Env: withEnv :: TCEnv -> TCM a -> TCM a

- Agda.TypeChecking.Monad.MetaVars: addInteractionPoint :: MonadTCM tcm => InteractionId -> MetaId -> tcm ()

+ Agda.TypeChecking.Monad.MetaVars: addInteractionPoint :: InteractionId -> MetaId -> TCM ()

- Agda.TypeChecking.Monad.MetaVars: clearMetaListeners :: MonadTCM tcm => MetaId -> tcm ()

+ Agda.TypeChecking.Monad.MetaVars: clearMetaListeners :: MetaId -> TCM ()

- Agda.TypeChecking.Monad.MetaVars: createMetaInfo :: MonadTCM tcm => tcm MetaInfo

+ Agda.TypeChecking.Monad.MetaVars: createMetaInfo :: TCM MetaInfo

- Agda.TypeChecking.Monad.MetaVars: getInstantiatedMetas :: MonadTCM tcm => tcm [MetaId]

+ Agda.TypeChecking.Monad.MetaVars: getInstantiatedMetas :: TCM [MetaId]

- Agda.TypeChecking.Monad.MetaVars: getInteractionMetas :: MonadTCM tcm => tcm [MetaId]

+ Agda.TypeChecking.Monad.MetaVars: getInteractionMetas :: TCM [MetaId]

- Agda.TypeChecking.Monad.MetaVars: getInteractionPoints :: MonadTCM tcm => tcm [InteractionId]

+ Agda.TypeChecking.Monad.MetaVars: getInteractionPoints :: TCM [InteractionId]

- Agda.TypeChecking.Monad.MetaVars: getInteractionRange :: MonadTCM tcm => InteractionId -> tcm Range

+ Agda.TypeChecking.Monad.MetaVars: getInteractionRange :: InteractionId -> TCM Range

- Agda.TypeChecking.Monad.MetaVars: getInteractionScope :: MonadTCM tcm => InteractionId -> tcm ScopeInfo

+ Agda.TypeChecking.Monad.MetaVars: getInteractionScope :: InteractionId -> TCM ScopeInfo

- Agda.TypeChecking.Monad.MetaVars: getMetaListeners :: MonadTCM tcm => MetaId -> tcm [MetaId]

+ Agda.TypeChecking.Monad.MetaVars: getMetaListeners :: MetaId -> TCM [Listener]

- Agda.TypeChecking.Monad.MetaVars: getMetaPriority :: MonadTCM tcm => MetaId -> tcm MetaPriority

+ Agda.TypeChecking.Monad.MetaVars: getMetaPriority :: MetaId -> TCM MetaPriority

- Agda.TypeChecking.Monad.MetaVars: getMetaRange :: MonadTCM tcm => MetaId -> tcm Range

+ Agda.TypeChecking.Monad.MetaVars: getMetaRange :: MetaId -> TCM Range

- Agda.TypeChecking.Monad.MetaVars: getMetaStore :: MonadTCM tcm => tcm MetaStore

+ Agda.TypeChecking.Monad.MetaVars: getMetaStore :: TCM MetaStore

- Agda.TypeChecking.Monad.MetaVars: getOpenMetas :: MonadTCM tcm => tcm [MetaId]

+ Agda.TypeChecking.Monad.MetaVars: getOpenMetas :: TCM [MetaId]

- Agda.TypeChecking.Monad.MetaVars: isInstantiatedMeta :: MonadTCM tcm => MetaId -> tcm Bool

+ Agda.TypeChecking.Monad.MetaVars: isInstantiatedMeta :: MetaId -> TCM Bool

- Agda.TypeChecking.Monad.MetaVars: isInteractionMeta :: MonadTCM tcm => MetaId -> tcm Bool

+ Agda.TypeChecking.Monad.MetaVars: isInteractionMeta :: MetaId -> TCM Bool

- Agda.TypeChecking.Monad.MetaVars: isSortMeta :: MonadTCM tcm => MetaId -> tcm Bool

+ Agda.TypeChecking.Monad.MetaVars: isSortMeta :: MetaId -> TCM Bool

- Agda.TypeChecking.Monad.MetaVars: judgementInteractionId :: MonadTCM tcm => InteractionId -> tcm (Judgement Type MetaId)

+ Agda.TypeChecking.Monad.MetaVars: judgementInteractionId :: InteractionId -> TCM (Judgement Type MetaId)

- Agda.TypeChecking.Monad.MetaVars: listenToMeta :: MonadTCM tcm => MetaId -> MetaId -> tcm ()

+ Agda.TypeChecking.Monad.MetaVars: listenToMeta :: Listener -> MetaId -> TCM ()

- Agda.TypeChecking.Monad.MetaVars: lookupInteractionId :: MonadTCM tcm => InteractionId -> tcm MetaId

+ Agda.TypeChecking.Monad.MetaVars: lookupInteractionId :: InteractionId -> TCM MetaId

- Agda.TypeChecking.Monad.MetaVars: lookupMeta :: MonadTCM tcm => MetaId -> tcm MetaVariable

+ Agda.TypeChecking.Monad.MetaVars: lookupMeta :: MetaId -> TCM MetaVariable

- Agda.TypeChecking.Monad.MetaVars: newMeta :: MonadTCM tcm => MetaInfo -> MetaPriority -> Permutation -> Judgement Type a -> tcm MetaId

+ Agda.TypeChecking.Monad.MetaVars: newMeta :: MetaInfo -> MetaPriority -> Permutation -> Judgement Type a -> TCM MetaId

- Agda.TypeChecking.Monad.MetaVars: newMeta' :: MonadTCM tcm => MetaInstantiation -> MetaInfo -> MetaPriority -> Permutation -> Judgement Type a -> tcm MetaId

+ Agda.TypeChecking.Monad.MetaVars: newMeta' :: MetaInstantiation -> MetaInfo -> MetaPriority -> Permutation -> Judgement Type a -> TCM MetaId

- Agda.TypeChecking.Monad.MetaVars: removeInteractionPoint :: MonadTCM tcm => InteractionId -> tcm ()

+ Agda.TypeChecking.Monad.MetaVars: removeInteractionPoint :: InteractionId -> TCM ()

- Agda.TypeChecking.Monad.MetaVars: unlistenToMeta :: MonadTCM tcm => MetaId -> MetaId -> tcm ()

+ Agda.TypeChecking.Monad.MetaVars: unlistenToMeta :: Listener -> MetaId -> TCM ()

- Agda.TypeChecking.Monad.MetaVars: updateMetaVar :: MonadTCM tcm => MetaId -> (MetaVariable -> MetaVariable) -> tcm ()

+ Agda.TypeChecking.Monad.MetaVars: updateMetaVar :: MetaId -> (MetaVariable -> MetaVariable) -> TCM ()

- Agda.TypeChecking.Monad.MetaVars: updateMetaVarRange :: MonadTCM tcm => MetaId -> Range -> tcm ()

+ Agda.TypeChecking.Monad.MetaVars: updateMetaVarRange :: MetaId -> Range -> TCM ()

- Agda.TypeChecking.Monad.MetaVars: withMetaInfo :: MonadTCM tcm => MetaInfo -> tcm a -> tcm a

+ Agda.TypeChecking.Monad.MetaVars: withMetaInfo :: MetaInfo -> TCM a -> TCM a

- Agda.TypeChecking.Monad.Mutual: currentMutualBlock :: MonadTCM tcm => tcm MutualId

+ Agda.TypeChecking.Monad.Mutual: currentMutualBlock :: TCM MutualId

- Agda.TypeChecking.Monad.Mutual: findMutualBlock :: MonadTCM tcm => QName -> tcm (Set QName)

+ Agda.TypeChecking.Monad.Mutual: findMutualBlock :: QName -> TCM (Set QName)

- Agda.TypeChecking.Monad.Mutual: getMutualBlocks :: MonadTCM tcm => tcm [Set QName]

+ Agda.TypeChecking.Monad.Mutual: getMutualBlocks :: TCM [Set QName]

- Agda.TypeChecking.Monad.Mutual: inMutualBlock :: MonadTCM tcm => tcm a -> tcm a

+ Agda.TypeChecking.Monad.Mutual: inMutualBlock :: TCM a -> TCM a

- Agda.TypeChecking.Monad.Mutual: lookupMutualBlock :: MonadTCM tcm => MutualId -> tcm (Set QName)

+ Agda.TypeChecking.Monad.Mutual: lookupMutualBlock :: MutualId -> TCM (Set QName)

- Agda.TypeChecking.Monad.Mutual: noMutualBlock :: MonadTCM tcm => tcm a -> tcm a

+ Agda.TypeChecking.Monad.Mutual: noMutualBlock :: TCM a -> TCM a

- Agda.TypeChecking.Monad.Mutual: setMutualBlock :: MonadTCM tcm => MutualId -> QName -> tcm ()

+ Agda.TypeChecking.Monad.Mutual: setMutualBlock :: MutualId -> QName -> TCM ()

- Agda.TypeChecking.Monad.Open: getOpen :: (MonadTCM tcm, Raise a) => Open a -> tcm a

+ Agda.TypeChecking.Monad.Open: getOpen :: Raise a => Open a -> TCM a

- Agda.TypeChecking.Monad.Open: makeOpen :: MonadTCM tcm => a -> tcm (Open a)

+ Agda.TypeChecking.Monad.Open: makeOpen :: a -> TCM (Open a)

- Agda.TypeChecking.Monad.Open: tryOpen :: (MonadTCM tcm, Raise a) => Open a -> tcm (Maybe a)

+ Agda.TypeChecking.Monad.Open: tryOpen :: Raise a => Open a -> TCM (Maybe a)

- Agda.TypeChecking.Monad.Options: commandLineOptions :: MonadTCM tcm => tcm CommandLineOptions

+ Agda.TypeChecking.Monad.Options: commandLineOptions :: TCM CommandLineOptions

- Agda.TypeChecking.Monad.Options: disableDisplayForms :: MonadTCM tcm => tcm a -> tcm a

+ Agda.TypeChecking.Monad.Options: disableDisplayForms :: TCM a -> TCM a

- Agda.TypeChecking.Monad.Options: displayFormsEnabled :: MonadTCM tcm => tcm Bool

+ Agda.TypeChecking.Monad.Options: displayFormsEnabled :: TCM Bool

- Agda.TypeChecking.Monad.Options: dontEtaContractImplicit :: MonadTCM tcm => tcm a -> tcm a

+ Agda.TypeChecking.Monad.Options: dontEtaContractImplicit :: TCM a -> TCM a

- Agda.TypeChecking.Monad.Options: dontReifyInteractionPoints :: MonadTCM tcm => tcm a -> tcm a

+ Agda.TypeChecking.Monad.Options: dontReifyInteractionPoints :: TCM a -> TCM a

- Agda.TypeChecking.Monad.Options: enableDisplayForms :: MonadTCM tcm => tcm a -> tcm a

+ Agda.TypeChecking.Monad.Options: enableDisplayForms :: TCM a -> TCM a

- Agda.TypeChecking.Monad.Options: getIncludeDirs :: MonadTCM tcm => tcm [AbsolutePath]

+ Agda.TypeChecking.Monad.Options: getIncludeDirs :: TCM [AbsolutePath]

- Agda.TypeChecking.Monad.Options: getInputFile :: MonadTCM tcm => tcm AbsolutePath

+ Agda.TypeChecking.Monad.Options: getInputFile :: TCM AbsolutePath

- Agda.TypeChecking.Monad.Options: getVerbosity :: MonadTCM tcm => tcm (Trie String Int)

+ Agda.TypeChecking.Monad.Options: getVerbosity :: TCM (Trie String Int)

- Agda.TypeChecking.Monad.Options: hasInputFile :: MonadTCM tcm => tcm Bool

+ Agda.TypeChecking.Monad.Options: hasInputFile :: TCM Bool

- Agda.TypeChecking.Monad.Options: hasUniversePolymorphism :: MonadTCM tcm => tcm Bool

+ Agda.TypeChecking.Monad.Options: hasUniversePolymorphism :: TCM Bool

- Agda.TypeChecking.Monad.Options: hasVerbosity :: MonadTCM tcm => VerboseKey -> Int -> tcm Bool

+ Agda.TypeChecking.Monad.Options: hasVerbosity :: VerboseKey -> Int -> TCM Bool

- Agda.TypeChecking.Monad.Options: ignoreInterfaces :: MonadTCM tcm => tcm Bool

+ Agda.TypeChecking.Monad.Options: ignoreInterfaces :: TCM Bool

- Agda.TypeChecking.Monad.Options: positivityCheckEnabled :: MonadTCM tcm => tcm Bool

+ Agda.TypeChecking.Monad.Options: positivityCheckEnabled :: TCM Bool

- Agda.TypeChecking.Monad.Options: pragmaOptions :: MonadTCM tcm => tcm PragmaOptions

+ Agda.TypeChecking.Monad.Options: pragmaOptions :: TCM PragmaOptions

- Agda.TypeChecking.Monad.Options: proofIrrelevance :: MonadTCM tcm => tcm Bool

+ Agda.TypeChecking.Monad.Options: proofIrrelevance :: TCM Bool

- Agda.TypeChecking.Monad.Options: reportS :: MonadTCM tcm => VerboseKey -> Int -> String -> tcm ()

+ Agda.TypeChecking.Monad.Options: reportS :: VerboseKey -> Int -> String -> TCM ()

- Agda.TypeChecking.Monad.Options: reportSDoc :: MonadTCM tcm => VerboseKey -> Int -> tcm Doc -> tcm ()

+ Agda.TypeChecking.Monad.Options: reportSDoc :: VerboseKey -> Int -> TCM Doc -> TCM ()

- Agda.TypeChecking.Monad.Options: reportSLn :: MonadTCM tcm => VerboseKey -> Int -> String -> tcm ()

+ Agda.TypeChecking.Monad.Options: reportSLn :: VerboseKey -> Int -> String -> TCM ()

- Agda.TypeChecking.Monad.Options: setCommandLineOptions :: MonadTCM tcm => CommandLineOptions -> tcm ()

+ Agda.TypeChecking.Monad.Options: setCommandLineOptions :: CommandLineOptions -> TCM ()

- Agda.TypeChecking.Monad.Options: setIncludeDirs :: MonadTCM tcm => [FilePath] -> RelativeTo -> tcm ()

+ Agda.TypeChecking.Monad.Options: setIncludeDirs :: [FilePath] -> RelativeTo -> TCM ()

- Agda.TypeChecking.Monad.Options: setInputFile :: MonadTCM tcm => FilePath -> tcm ()

+ Agda.TypeChecking.Monad.Options: setInputFile :: FilePath -> TCM ()

- Agda.TypeChecking.Monad.Options: setOptionsFromPragma :: MonadTCM tcm => OptionsPragma -> tcm ()

+ Agda.TypeChecking.Monad.Options: setOptionsFromPragma :: OptionsPragma -> TCM ()

- Agda.TypeChecking.Monad.Options: setPragmaOptions :: MonadTCM tcm => PragmaOptions -> tcm ()

+ Agda.TypeChecking.Monad.Options: setPragmaOptions :: PragmaOptions -> TCM ()

- Agda.TypeChecking.Monad.Options: setShowImplicitArguments :: MonadTCM tcm => Bool -> tcm a -> tcm a

+ Agda.TypeChecking.Monad.Options: setShowImplicitArguments :: Bool -> TCM a -> TCM a

- Agda.TypeChecking.Monad.Options: shouldEtaContractImplicit :: MonadTCM tcm => tcm Bool

+ Agda.TypeChecking.Monad.Options: shouldEtaContractImplicit :: TCM Bool

- Agda.TypeChecking.Monad.Options: shouldReifyInteractionPoints :: MonadTCM tcm => tcm Bool

+ Agda.TypeChecking.Monad.Options: shouldReifyInteractionPoints :: TCM Bool

- Agda.TypeChecking.Monad.Options: showImplicitArguments :: MonadTCM tcm => tcm Bool

+ Agda.TypeChecking.Monad.Options: showImplicitArguments :: TCM Bool

- Agda.TypeChecking.Monad.Options: typeInType :: MonadTCM tcm => tcm Bool

+ Agda.TypeChecking.Monad.Options: typeInType :: TCM Bool

- Agda.TypeChecking.Monad.Options: verboseBracket :: MonadTCM tcm => VerboseKey -> Int -> String -> tcm a -> tcm a

+ Agda.TypeChecking.Monad.Options: verboseBracket :: VerboseKey -> Int -> String -> TCM a -> TCM a

- Agda.TypeChecking.Monad.Options: verboseS :: MonadTCM tcm => VerboseKey -> Int -> tcm () -> tcm ()

+ Agda.TypeChecking.Monad.Options: verboseS :: VerboseKey -> Int -> TCM () -> TCM ()

- Agda.TypeChecking.Monad.Signature: addConstant :: MonadTCM tcm => QName -> Definition -> tcm ()

+ Agda.TypeChecking.Monad.Signature: addConstant :: QName -> Definition -> TCM ()

- Agda.TypeChecking.Monad.Signature: addDisplayForm :: MonadTCM tcm => QName -> DisplayForm -> tcm ()

+ Agda.TypeChecking.Monad.Signature: addDisplayForm :: QName -> DisplayForm -> TCM ()

- Agda.TypeChecking.Monad.Signature: addEpicCode :: MonadTCM tcm => QName -> EpicCode -> tcm ()

+ Agda.TypeChecking.Monad.Signature: addEpicCode :: QName -> EpicCode -> TCM ()

- Agda.TypeChecking.Monad.Signature: addHaskellCode :: MonadTCM tcm => QName -> HaskellType -> HaskellCode -> tcm ()

+ Agda.TypeChecking.Monad.Signature: addHaskellCode :: QName -> HaskellType -> HaskellCode -> TCM ()

- Agda.TypeChecking.Monad.Signature: addHaskellType :: MonadTCM tcm => QName -> HaskellType -> tcm ()

+ Agda.TypeChecking.Monad.Signature: addHaskellType :: QName -> HaskellType -> TCM ()

- Agda.TypeChecking.Monad.Signature: addSection :: MonadTCM tcm => ModuleName -> Nat -> tcm ()

+ Agda.TypeChecking.Monad.Signature: addSection :: ModuleName -> Nat -> TCM ()

- Agda.TypeChecking.Monad.Signature: applySection :: MonadTCM tcm => ModuleName -> Telescope -> ModuleName -> Args -> Map QName QName -> Map ModuleName ModuleName -> tcm ()

+ Agda.TypeChecking.Monad.Signature: applySection :: ModuleName -> Telescope -> ModuleName -> Args -> Map QName QName -> Map ModuleName ModuleName -> TCM ()

- Agda.TypeChecking.Monad.Signature: canonicalName :: MonadTCM tcm => QName -> tcm QName

+ Agda.TypeChecking.Monad.Signature: canonicalName :: QName -> TCM QName

- Agda.TypeChecking.Monad.Signature: freeVarsToApply :: MonadTCM tcm => QName -> tcm Args

+ Agda.TypeChecking.Monad.Signature: freeVarsToApply :: QName -> TCM Args

- Agda.TypeChecking.Monad.Signature: getArgOccurrence :: MonadTCM tcm => QName -> Nat -> tcm Occurrence

+ Agda.TypeChecking.Monad.Signature: getArgOccurrence :: QName -> Nat -> TCM Occurrence

- Agda.TypeChecking.Monad.Signature: getDefFreeVars :: MonadTCM tcm => QName -> tcm Nat

+ Agda.TypeChecking.Monad.Signature: getDefFreeVars :: QName -> TCM Nat

- Agda.TypeChecking.Monad.Signature: getImportedSignature :: MonadTCM tcm => tcm Signature

+ Agda.TypeChecking.Monad.Signature: getImportedSignature :: TCM Signature

- Agda.TypeChecking.Monad.Signature: getModuleFreeVars :: MonadTCM tcm => ModuleName -> tcm Nat

+ Agda.TypeChecking.Monad.Signature: getModuleFreeVars :: ModuleName -> TCM Nat

- Agda.TypeChecking.Monad.Signature: getPolarity :: MonadTCM tcm => QName -> tcm [Polarity]

+ Agda.TypeChecking.Monad.Signature: getPolarity :: QName -> TCM [Polarity]

- Agda.TypeChecking.Monad.Signature: getPolarity' :: MonadTCM tcm => Comparison -> QName -> tcm [Polarity]

+ Agda.TypeChecking.Monad.Signature: getPolarity' :: Comparison -> QName -> TCM [Polarity]

- Agda.TypeChecking.Monad.Signature: getSecFreeVars :: MonadTCM tcm => ModuleName -> tcm Nat

+ Agda.TypeChecking.Monad.Signature: getSecFreeVars :: ModuleName -> TCM Nat

- Agda.TypeChecking.Monad.Signature: getSignature :: MonadTCM tcm => tcm Signature

+ Agda.TypeChecking.Monad.Signature: getSignature :: TCM Signature

- Agda.TypeChecking.Monad.Signature: ignoreAbstractMode :: MonadTCM tcm => tcm a -> tcm a

+ Agda.TypeChecking.Monad.Signature: ignoreAbstractMode :: TCM a -> TCM a

- Agda.TypeChecking.Monad.Signature: inAbstractMode :: MonadTCM tcm => tcm a -> tcm a

+ Agda.TypeChecking.Monad.Signature: inAbstractMode :: TCM a -> TCM a

- Agda.TypeChecking.Monad.Signature: inConcreteMode :: MonadTCM tcm => tcm a -> tcm a

+ Agda.TypeChecking.Monad.Signature: inConcreteMode :: TCM a -> TCM a

- Agda.TypeChecking.Monad.Signature: instantiateDef :: MonadTCM tcm => Definition -> tcm Definition

+ Agda.TypeChecking.Monad.Signature: instantiateDef :: Definition -> TCM Definition

- Agda.TypeChecking.Monad.Signature: isProjection :: MonadTCM tcm => QName -> tcm (Maybe Int)

+ Agda.TypeChecking.Monad.Signature: isProjection :: QName -> TCM (Maybe (QName, Int))

- Agda.TypeChecking.Monad.Signature: lookupSection :: MonadTCM tcm => ModuleName -> tcm Telescope

+ Agda.TypeChecking.Monad.Signature: lookupSection :: ModuleName -> TCM Telescope

- Agda.TypeChecking.Monad.Signature: modifyImportedSignature :: MonadTCM tcm => (Signature -> Signature) -> tcm ()

+ Agda.TypeChecking.Monad.Signature: modifyImportedSignature :: (Signature -> Signature) -> TCM ()

- Agda.TypeChecking.Monad.Signature: modifySignature :: MonadTCM tcm => (Signature -> Signature) -> tcm ()

+ Agda.TypeChecking.Monad.Signature: modifySignature :: (Signature -> Signature) -> TCM ()

- Agda.TypeChecking.Monad.Signature: relOfConst :: MonadTCM tcm => QName -> tcm Relevance

+ Agda.TypeChecking.Monad.Signature: relOfConst :: QName -> TCM Relevance

- Agda.TypeChecking.Monad.Signature: setArgOccurrences :: MonadTCM tcm => QName -> [Occurrence] -> tcm ()

+ Agda.TypeChecking.Monad.Signature: setArgOccurrences :: QName -> [Occurrence] -> TCM ()

- Agda.TypeChecking.Monad.Signature: setImportedSignature :: MonadTCM tcm => Signature -> tcm ()

+ Agda.TypeChecking.Monad.Signature: setImportedSignature :: Signature -> TCM ()

- Agda.TypeChecking.Monad.Signature: setPolarity :: MonadTCM tcm => QName -> [Polarity] -> tcm ()

+ Agda.TypeChecking.Monad.Signature: setPolarity :: QName -> [Polarity] -> TCM ()

- Agda.TypeChecking.Monad.Signature: setSignature :: MonadTCM tcm => Signature -> tcm ()

+ Agda.TypeChecking.Monad.Signature: setSignature :: Signature -> TCM ()

- Agda.TypeChecking.Monad.Signature: sortOfConst :: MonadTCM tcm => QName -> tcm Sort

+ Agda.TypeChecking.Monad.Signature: sortOfConst :: QName -> TCM Sort

- Agda.TypeChecking.Monad.Signature: treatAbstractly :: MonadTCM tcm => QName -> tcm Bool

+ Agda.TypeChecking.Monad.Signature: treatAbstractly :: QName -> TCM Bool

- Agda.TypeChecking.Monad.Signature: typeOfConst :: MonadTCM tcm => QName -> tcm Type

+ Agda.TypeChecking.Monad.Signature: typeOfConst :: QName -> TCM Type

- Agda.TypeChecking.Monad.Signature: whatInduction :: MonadTCM tcm => QName -> tcm Induction

+ Agda.TypeChecking.Monad.Signature: whatInduction :: QName -> TCM Induction

- Agda.TypeChecking.Monad.Signature: withSignature :: MonadTCM tcm => Signature -> tcm a -> tcm a

+ Agda.TypeChecking.Monad.Signature: withSignature :: Signature -> TCM a -> TCM a

- Agda.TypeChecking.Monad.SizedTypes: isSizeType :: MonadTCM tcm => Type -> tcm Bool

+ Agda.TypeChecking.Monad.SizedTypes: isSizeType :: Type -> TCM Bool

- Agda.TypeChecking.Monad.SizedTypes: sizeSuc :: MonadTCM tcm => tcm (Maybe QName)

+ Agda.TypeChecking.Monad.SizedTypes: sizeSuc :: TCM (Maybe QName)

- Agda.TypeChecking.Monad.SizedTypes: sizeType :: MonadTCM tcm => tcm Type

+ Agda.TypeChecking.Monad.SizedTypes: sizeType :: TCM Type

- Agda.TypeChecking.Monad.SizedTypes: sizeView :: MonadTCM tcm => Term -> tcm SizeView

+ Agda.TypeChecking.Monad.SizedTypes: sizeView :: Term -> TCM SizeView

- Agda.TypeChecking.Monad.SizedTypes: unSizeView :: MonadTCM tcm => SizeView -> tcm Term

+ Agda.TypeChecking.Monad.SizedTypes: unSizeView :: SizeView -> TCM Term

- Agda.TypeChecking.Monad.State: addHaskellImport :: MonadTCM tcm => String -> tcm ()

+ Agda.TypeChecking.Monad.State: addHaskellImport :: String -> TCM ()

- Agda.TypeChecking.Monad.State: getHaskellImports :: MonadTCM tcm => tcm (Set String)

+ Agda.TypeChecking.Monad.State: getHaskellImports :: TCM (Set String)

- Agda.TypeChecking.Monad.State: getScope :: MonadTCM tcm => tcm ScopeInfo

+ Agda.TypeChecking.Monad.State: getScope :: TCM ScopeInfo

- Agda.TypeChecking.Monad.State: localScope :: MonadTCM tcm => tcm a -> tcm a

+ Agda.TypeChecking.Monad.State: localScope :: TCM a -> TCM a

- Agda.TypeChecking.Monad.State: modifyScope :: MonadTCM tcm => (ScopeInfo -> ScopeInfo) -> tcm ()

+ Agda.TypeChecking.Monad.State: modifyScope :: (ScopeInfo -> ScopeInfo) -> TCM ()

- Agda.TypeChecking.Monad.State: resetState :: MonadTCM tcm => tcm ()

+ Agda.TypeChecking.Monad.State: resetState :: TCM ()

- Agda.TypeChecking.Monad.State: setScope :: MonadTCM tcm => ScopeInfo -> tcm ()

+ Agda.TypeChecking.Monad.State: setScope :: ScopeInfo -> TCM ()

- Agda.TypeChecking.Monad.State: setTopLevelModule :: MonadTCM tcm => QName -> tcm ()

+ Agda.TypeChecking.Monad.State: setTopLevelModule :: QName -> TCM ()

- Agda.TypeChecking.Monad.State: withScope :: MonadTCM tcm => ScopeInfo -> tcm a -> tcm (a, ScopeInfo)

+ Agda.TypeChecking.Monad.State: withScope :: ScopeInfo -> TCM a -> TCM (a, ScopeInfo)

- Agda.TypeChecking.Monad.State: withScope_ :: MonadTCM tcm => ScopeInfo -> tcm a -> tcm a

+ Agda.TypeChecking.Monad.State: withScope_ :: ScopeInfo -> TCM a -> TCM a

- Agda.TypeChecking.Monad.State: withTopLevelModule :: MonadTCM tcm => QName -> tcm a -> tcm a

+ Agda.TypeChecking.Monad.State: withTopLevelModule :: QName -> TCM a -> TCM a

- Agda.TypeChecking.Monad.Trace: getCurrentRange :: MonadTCM tcm => tcm Range

+ Agda.TypeChecking.Monad.Trace: getCurrentRange :: TCM Range

- Agda.TypeChecking.Monad.Trace: setCurrentRange :: MonadTCM tcm => Range -> tcm a -> tcm a

+ Agda.TypeChecking.Monad.Trace: setCurrentRange :: Range -> TCM a -> TCM a

- Agda.TypeChecking.Patterns.Match: matchPattern :: MonadTCM tcm => Arg Pattern -> Arg Term -> tcm (Match, Arg Term)

+ Agda.TypeChecking.Patterns.Match: matchPattern :: Arg Pattern -> Arg Term -> TCM (Match, Arg Term)

- Agda.TypeChecking.Patterns.Match: matchPatterns :: MonadTCM tcm => [Arg Pattern] -> [Arg Term] -> tcm (Match, [Arg Term])

+ Agda.TypeChecking.Patterns.Match: matchPatterns :: [Arg Pattern] -> [Arg Term] -> TCM (Match, [Arg Term])

- Agda.TypeChecking.Pretty: prettyTCM :: (PrettyTCM a, MonadTCM tcm) => a -> tcm Doc

+ Agda.TypeChecking.Pretty: prettyTCM :: PrettyTCM a => a -> TCM Doc

- Agda.TypeChecking.Primitive: (-->) :: MonadTCM tcm => tcm Type -> tcm Type -> tcm Type

+ Agda.TypeChecking.Primitive: (-->) :: TCM Type -> TCM Type -> TCM Type

- Agda.TypeChecking.Primitive: buildList :: MonadTCM tcm => tcm ([Term] -> Term)

+ Agda.TypeChecking.Primitive: buildList :: TCM ([Term] -> Term)

- Agda.TypeChecking.Primitive: constructorForm :: MonadTCM tcm => Term -> tcm Term

+ Agda.TypeChecking.Primitive: constructorForm :: Term -> TCM Term

- Agda.TypeChecking.Primitive: el :: MonadTCM tcm => tcm Term -> tcm Type

+ Agda.TypeChecking.Primitive: el :: TCM Term -> TCM Type

- Agda.TypeChecking.Primitive: fromLiteral :: MonadTCM tcm => (Literal -> Maybe a) -> tcm (FromTermFunction a)

+ Agda.TypeChecking.Primitive: fromLiteral :: (Literal -> Maybe a) -> TCM (FromTermFunction a)

- Agda.TypeChecking.Primitive: fromReducedTerm :: MonadTCM tcm => (Term -> Maybe a) -> tcm (FromTermFunction a)

+ Agda.TypeChecking.Primitive: fromReducedTerm :: (Term -> Maybe a) -> TCM (FromTermFunction a)

- Agda.TypeChecking.Primitive: fromTerm :: (FromTerm a, MonadTCM tcm) => tcm (FromTermFunction a)

+ Agda.TypeChecking.Primitive: fromTerm :: FromTerm a => TCM (FromTermFunction a)

- Agda.TypeChecking.Primitive: gApply :: MonadTCM tcm => Hiding -> tcm Term -> tcm Term -> tcm Term

+ Agda.TypeChecking.Primitive: gApply :: Hiding -> TCM Term -> TCM Term -> TCM Term

- Agda.TypeChecking.Primitive: gpi :: MonadTCM tcm => Hiding -> Relevance -> String -> tcm Type -> tcm Type -> tcm Type

+ Agda.TypeChecking.Primitive: gpi :: Hiding -> Relevance -> String -> TCM Type -> TCM Type -> TCM Type

- Agda.TypeChecking.Primitive: io :: MonadTCM tcm => tcm Term -> tcm Term

+ Agda.TypeChecking.Primitive: io :: TCM Term -> TCM Term

- Agda.TypeChecking.Primitive: list :: MonadTCM tcm => tcm Term -> tcm Term

+ Agda.TypeChecking.Primitive: list :: TCM Term -> TCM Term

- Agda.TypeChecking.Primitive: lookupPrimitiveFunction :: MonadTCM tcm => String -> tcm PrimitiveImpl

+ Agda.TypeChecking.Primitive: lookupPrimitiveFunction :: String -> TCM PrimitiveImpl

- Agda.TypeChecking.Primitive: mkPrimFun1 :: (MonadTCM tcm, PrimType a, PrimType b, FromTerm a, ToTerm b) => (a -> b) -> tcm PrimitiveImpl

+ Agda.TypeChecking.Primitive: mkPrimFun1 :: (PrimType a, PrimType b, FromTerm a, ToTerm b) => (a -> b) -> TCM PrimitiveImpl

- Agda.TypeChecking.Primitive: mkPrimFun2 :: (MonadTCM tcm, PrimType a, PrimType b, PrimType c, FromTerm a, ToTerm a, FromTerm b, ToTerm c) => (a -> b -> c) -> tcm PrimitiveImpl

+ Agda.TypeChecking.Primitive: mkPrimFun2 :: (PrimType a, PrimType b, PrimType c, FromTerm a, ToTerm a, FromTerm b, ToTerm c) => (a -> b -> c) -> TCM PrimitiveImpl

- Agda.TypeChecking.Primitive: mkPrimFun4 :: (MonadTCM tcm, PrimType a, FromTerm a, ToTerm a, PrimType b, FromTerm b, ToTerm b, PrimType c, FromTerm c, ToTerm c, PrimType d, FromTerm d, PrimType e, ToTerm e) => (a -> b -> c -> d -> e) -> tcm PrimitiveImpl

+ Agda.TypeChecking.Primitive: mkPrimFun4 :: (PrimType a, FromTerm a, ToTerm a, PrimType b, FromTerm b, ToTerm b, PrimType c, FromTerm c, ToTerm c, PrimType d, FromTerm d, PrimType e, ToTerm e) => (a -> b -> c -> d -> e) -> TCM PrimitiveImpl

- Agda.TypeChecking.Primitive: primTerm :: (PrimTerm a, MonadTCM tcm) => a -> tcm Term

+ Agda.TypeChecking.Primitive: primTerm :: PrimTerm a => a -> TCM Term

- Agda.TypeChecking.Primitive: primTrustMe :: MonadTCM tcm => tcm PrimitiveImpl

+ Agda.TypeChecking.Primitive: primTrustMe :: TCM PrimitiveImpl

- Agda.TypeChecking.Primitive: primType :: (PrimType a, MonadTCM tcm) => a -> tcm Type

+ Agda.TypeChecking.Primitive: primType :: PrimType a => a -> TCM Type

- Agda.TypeChecking.Primitive: rebindPrimitive :: MonadTCM tcm => String -> tcm PrimFun

+ Agda.TypeChecking.Primitive: rebindPrimitive :: String -> TCM PrimFun

- Agda.TypeChecking.Primitive: redBind :: MonadTCM tcm => tcm (Reduced a a') -> (a -> b) -> (a' -> tcm (Reduced b b')) -> tcm (Reduced b b')

+ Agda.TypeChecking.Primitive: redBind :: TCM (Reduced a a') -> (a -> b) -> (a' -> TCM (Reduced b b')) -> TCM (Reduced b b')

- Agda.TypeChecking.Primitive: redReturn :: MonadTCM tcm => a -> tcm (Reduced a' a)

+ Agda.TypeChecking.Primitive: redReturn :: a -> TCM (Reduced a' a)

- Agda.TypeChecking.Primitive: toTerm :: (ToTerm a, MonadTCM tcm) => tcm (a -> Term)

+ Agda.TypeChecking.Primitive: toTerm :: ToTerm a => TCM (a -> Term)

- Agda.TypeChecking.Primitive: tset :: MonadTCM tcm => tcm Type

+ Agda.TypeChecking.Primitive: tset :: TCM Type

- Agda.TypeChecking.Primitive: var :: MonadTCM tcm => Integer -> tcm Term

+ Agda.TypeChecking.Primitive: var :: Integer -> TCM Term

- Agda.TypeChecking.Rebind: rebindClause :: Clauses -> TCM Clauses

+ Agda.TypeChecking.Rebind: rebindClause :: Clause -> TCM Clause

- Agda.TypeChecking.RecordPatterns: translateRecordPatterns :: MonadTCM tcm => Clause -> tcm Clauses

+ Agda.TypeChecking.RecordPatterns: translateRecordPatterns :: Clause -> TCM Clause

- Agda.TypeChecking.Records: etaContractRecord :: MonadTCM tcm => QName -> QName -> Args -> tcm Term

+ Agda.TypeChecking.Records: etaContractRecord :: QName -> QName -> Args -> TCM Term

- Agda.TypeChecking.Records: etaExpandRecord :: MonadTCM tcm => QName -> Args -> Term -> tcm (Telescope, Args)

+ Agda.TypeChecking.Records: etaExpandRecord :: QName -> Args -> Term -> TCM (Telescope, Args)

- Agda.TypeChecking.Records: getRecordConstructor :: MonadTCM tcm => QName -> tcm QName

+ Agda.TypeChecking.Records: getRecordConstructor :: QName -> TCM QName

- Agda.TypeChecking.Records: getRecordConstructorType :: MonadTCM tcm => QName -> tcm Type

+ Agda.TypeChecking.Records: getRecordConstructorType :: QName -> TCM Type

- Agda.TypeChecking.Records: getRecordDef :: MonadTCM tcm => QName -> tcm Defn

+ Agda.TypeChecking.Records: getRecordDef :: QName -> TCM Defn

- Agda.TypeChecking.Records: getRecordFieldNames :: MonadTCM tcm => QName -> tcm [Arg Name]

+ Agda.TypeChecking.Records: getRecordFieldNames :: QName -> TCM [Arg Name]

- Agda.TypeChecking.Records: getRecordFieldTypes :: MonadTCM tcm => QName -> tcm Telescope

+ Agda.TypeChecking.Records: getRecordFieldTypes :: QName -> TCM Telescope

- Agda.TypeChecking.Records: isEtaRecord :: MonadTCM tcm => QName -> tcm Bool

+ Agda.TypeChecking.Records: isEtaRecord :: QName -> TCM Bool

- Agda.TypeChecking.Records: isGeneratedRecordConstructor :: MonadTCM tcm => QName -> tcm Bool

+ Agda.TypeChecking.Records: isGeneratedRecordConstructor :: QName -> TCM Bool

- Agda.TypeChecking.Records: isRecord :: MonadTCM tcm => QName -> tcm Bool

+ Agda.TypeChecking.Records: isRecord :: QName -> TCM Bool

- Agda.TypeChecking.Records: isRecordConstructor :: MonadTCM tcm => QName -> tcm Bool

+ Agda.TypeChecking.Records: isRecordConstructor :: QName -> TCM Bool

- Agda.TypeChecking.Records: isSingletonRecord :: MonadTCM tcm => QName -> Args -> tcm (Either MetaId Bool)

+ Agda.TypeChecking.Records: isSingletonRecord :: QName -> Args -> TCM (Either MetaId Bool)

- Agda.TypeChecking.Records: orderFields :: MonadTCM tcm => QName -> a -> [Name] -> [(Name, a)] -> tcm [a]

+ Agda.TypeChecking.Records: orderFields :: QName -> a -> [Name] -> [(Name, a)] -> TCM [a]

- Agda.TypeChecking.Reduce: instantiate :: (Instantiate t, MonadTCM tcm) => t -> tcm t

+ Agda.TypeChecking.Reduce: instantiate :: Instantiate t => t -> TCM t

- Agda.TypeChecking.Reduce: instantiateFull :: (InstantiateFull t, MonadTCM tcm) => t -> tcm t

+ Agda.TypeChecking.Reduce: instantiateFull :: InstantiateFull t => t -> TCM t

- Agda.TypeChecking.Reduce: normalise :: (Normalise t, MonadTCM tcm) => t -> tcm t

+ Agda.TypeChecking.Reduce: normalise :: Normalise t => t -> TCM t

- Agda.TypeChecking.Reduce: reduce :: (Reduce t, MonadTCM tcm) => t -> tcm t

+ Agda.TypeChecking.Reduce: reduce :: Reduce t => t -> TCM t

- Agda.TypeChecking.Reduce: reduceB :: (Reduce t, MonadTCM tcm) => t -> tcm (Blocked t)

+ Agda.TypeChecking.Reduce: reduceB :: Reduce t => t -> TCM (Blocked t)

- Agda.TypeChecking.Reduce: telViewM :: MonadTCM tcm => Type -> tcm TelView

+ Agda.TypeChecking.Reduce: telViewM :: Type -> TCM TelView

- Agda.TypeChecking.Reduce: traceFun :: MonadTCM tcm => String -> tcm a -> tcm a

+ Agda.TypeChecking.Reduce: traceFun :: String -> TCM a -> TCM a

- Agda.TypeChecking.Reduce: traceFun' :: (Show a, MonadTCM tcm) => String -> tcm a -> tcm a

+ Agda.TypeChecking.Reduce: traceFun' :: Show a => String -> TCM a -> TCM a

- Agda.TypeChecking.Reduce: unfoldDefinition :: MonadTCM tcm => Bool -> (Term -> tcm (Blocked Term)) -> Term -> QName -> Args -> tcm (Blocked Term)

+ Agda.TypeChecking.Reduce: unfoldDefinition :: Bool -> (Term -> TCM (Blocked Term)) -> Term -> QName -> Args -> TCM (Blocked Term)

- Agda.TypeChecking.Rules.Data: forceData :: MonadTCM tcm => QName -> Type -> tcm Type

+ Agda.TypeChecking.Rules.Data: forceData :: QName -> Type -> TCM Type

- Agda.TypeChecking.Rules.Data: isCoinductive :: MonadTCM tcm => Type -> tcm (Maybe Bool)

+ Agda.TypeChecking.Rules.Data: isCoinductive :: Type -> TCM (Maybe Bool)

- Agda.TypeChecking.Rules.Decl: checkMutual :: DeclInfo -> [TypeSignature] -> [Definition] -> TCM ()

+ Agda.TypeChecking.Rules.Decl: checkMutual :: DeclInfo -> [Declaration] -> TCM ()

- Agda.TypeChecking.Rules.Decl: checkSectionApplication :: ModuleInfo -> ModuleName -> Telescope -> ModuleName -> [NamedArg Expr] -> Map QName QName -> Map ModuleName ModuleName -> TCM ()

+ Agda.TypeChecking.Rules.Decl: checkSectionApplication :: ModuleInfo -> ModuleName -> ModuleApplication -> Map QName QName -> Map ModuleName ModuleName -> TCM ()

- Agda.TypeChecking.Rules.Def: WithFunction :: QName -> QName -> Telescope -> Telescope -> Telescope -> [Term] -> [Type] -> Type -> [Arg Pattern] -> Permutation -> [Clause] -> WithFunctionProblem

+ Agda.TypeChecking.Rules.Def: WithFunction :: QName -> QName -> Telescope -> Telescope -> Telescope -> [Term] -> [Type] -> Type -> [Arg Pattern] -> Permutation -> Permutation -> [Clause] -> WithFunctionProblem

- Agda.TypeChecking.Rules.Def: actualConstructor :: MonadTCM tcm => QName -> tcm QName

+ Agda.TypeChecking.Rules.Def: actualConstructor :: QName -> TCM QName

- Agda.TypeChecking.Rules.Def: checkClause :: Type -> Clause -> TCM Clauses

+ Agda.TypeChecking.Rules.Def: checkClause :: Type -> Clause -> TCM Clause

- Agda.TypeChecking.Rules.LHS: checkDotPattern :: DotPatternInst -> TCM Constraints

+ Agda.TypeChecking.Rules.LHS: checkDotPattern :: DotPatternInst -> TCM ()

- Agda.TypeChecking.Rules.LHS: noPatternMatchingOnCodata :: MonadTCM tcm => [Arg Pattern] -> tcm ()

+ Agda.TypeChecking.Rules.LHS: noPatternMatchingOnCodata :: [Arg Pattern] -> TCM ()

- Agda.TypeChecking.Rules.LHS.Instantiate: instantiateTel :: MonadTCM tcm => Substitution -> Telescope -> tcm (Telescope, Permutation, [Term], [Type])

+ Agda.TypeChecking.Rules.LHS.Instantiate: instantiateTel :: Substitution -> Telescope -> TCM (Telescope, Permutation, [Term], [Type])

- Agda.TypeChecking.Rules.LHS.Split: wellFormedIndices :: MonadTCM tcm => [Arg Term] -> [Arg Term] -> tcm ()

+ Agda.TypeChecking.Rules.LHS.Split: wellFormedIndices :: [Arg Term] -> [Arg Term] -> TCM ()

- Agda.TypeChecking.Rules.LHS.Unify: Equal :: Type -> Term -> Term -> Equality

+ Agda.TypeChecking.Rules.LHS.Unify: Equal :: TypeHH -> Term -> Term -> Equality

- Agda.TypeChecking.Rules.LHS.Unify: U :: ExceptionT UnifyException (StateT UnifyState TCM) a -> Unify a

+ Agda.TypeChecking.Rules.LHS.Unify: U :: ReaderT UnifyEnv (WriterT UnifyOutput (ExceptionT UnifyException (StateT UnifyState TCM))) a -> Unify a

- Agda.TypeChecking.Rules.LHS.Unify: dataOrRecordType :: MonadTCM tcm => QName -> Type -> tcm Type

+ Agda.TypeChecking.Rules.LHS.Unify: dataOrRecordType :: QName -> Type -> TCM (Maybe Type)

- Agda.TypeChecking.Rules.LHS.Unify: unUnify :: Unify a -> ExceptionT UnifyException (StateT UnifyState TCM) a

+ Agda.TypeChecking.Rules.LHS.Unify: unUnify :: Unify a -> ReaderT UnifyEnv (WriterT UnifyOutput (ExceptionT UnifyException (StateT UnifyState TCM))) a

- Agda.TypeChecking.Rules.LHS.Unify: ureduce :: Term -> Unify Term

+ Agda.TypeChecking.Rules.LHS.Unify: ureduce :: UReduce t => t -> Unify t

- Agda.TypeChecking.Rules.Record: checkRecDef :: DefInfo -> QName -> Maybe Constructor -> [LamBinding] -> Expr -> [Constructor] -> TCM ()

+ Agda.TypeChecking.Rules.Record: checkRecDef :: DefInfo -> QName -> Maybe QName -> [LamBinding] -> Expr -> [Constructor] -> TCM ()

- Agda.TypeChecking.Rules.Record: checkRecordProjections :: ModuleName -> QName -> Telescope -> Telescope -> [Declaration] -> TCM ()

+ Agda.TypeChecking.Rules.Record: checkRecordProjections :: ModuleName -> QName -> QName -> Telescope -> Telescope -> [Declaration] -> TCM ()

- Agda.TypeChecking.Rules.Term: checkArguments :: ExpandHidden -> Range -> [NamedArg Expr] -> Type -> Type -> ErrorT Type TCM (Args, Type, Constraints)

+ Agda.TypeChecking.Rules.Term: checkArguments :: ExpandHidden -> Range -> [NamedArg Expr] -> Type -> Type -> ErrorT Type TCM (Args, Type)

- Agda.TypeChecking.Rules.Term: checkArguments' :: ExpandHidden -> Range -> [NamedArg Expr] -> Type -> Type -> Expr -> (Args -> Type -> Constraints -> TCM Term) -> TCM Term

+ Agda.TypeChecking.Rules.Term: checkArguments' :: ExpandHidden -> Range -> [NamedArg Expr] -> Type -> Type -> Expr -> (Args -> Type -> TCM Term) -> TCM Term

- Agda.TypeChecking.Rules.Term: checkArguments_ :: ExpandHidden -> Range -> [NamedArg Expr] -> Telescope -> TCM (Args, Constraints)

+ Agda.TypeChecking.Rules.Term: checkArguments_ :: ExpandHidden -> Range -> [NamedArg Expr] -> Telescope -> TCM Args

- Agda.TypeChecking.Rules.Term: checkHeadApplication :: Expr -> Type -> Head -> [NamedArg Expr] -> TCM Term

+ Agda.TypeChecking.Rules.Term: checkHeadApplication :: Expr -> Type -> Expr -> [NamedArg Expr] -> TCM Term

- Agda.TypeChecking.Rules.Term: checkTypedBinding :: Hiding -> Sort -> TypedBinding -> ([(String, Type)] -> TCM a) -> TCM a

+ Agda.TypeChecking.Rules.Term: checkTypedBinding :: LamOrPi -> Hiding -> Relevance -> TypedBinding -> ([(String, Type)] -> TCM a) -> TCM a

- Agda.TypeChecking.Rules.Term: checkTypedBindings :: TypedBindings -> Sort -> (Telescope -> TCM a) -> TCM a

+ Agda.TypeChecking.Rules.Term: checkTypedBindings :: LamOrPi -> TypedBindings -> (Telescope -> TCM a) -> TCM a

- Agda.TypeChecking.Rules.Term: inferHead :: Head -> TCM (Args -> Term, Type)

+ Agda.TypeChecking.Rules.Term: inferHead :: Expr -> TCM (Args -> Term, Type)

- Agda.TypeChecking.Rules.Term: reduceCon :: MonadTCM tcm => QName -> tcm QName

+ Agda.TypeChecking.Rules.Term: reduceCon :: QName -> TCM QName

- Agda.TypeChecking.SizedTypes: compareSizes :: MonadTCM tcm => Comparison -> Term -> Term -> tcm Constraints

+ Agda.TypeChecking.SizedTypes: compareSizes :: Comparison -> Term -> Term -> TCM ()

- Agda.TypeChecking.SizedTypes: computeSizeConstraint :: MonadTCM tcm => ConstraintClosure -> tcm (Maybe SizeConstraint)

+ Agda.TypeChecking.SizedTypes: computeSizeConstraint :: Closure Constraint -> TCM (Maybe SizeConstraint)

- Agda.TypeChecking.SizedTypes: getSizeConstraints :: MonadTCM tcm => tcm [SizeConstraint]

+ Agda.TypeChecking.SizedTypes: getSizeConstraints :: TCM [SizeConstraint]

- Agda.TypeChecking.SizedTypes: getSizeMetas :: MonadTCM tcm => tcm [(MetaId, Int)]

+ Agda.TypeChecking.SizedTypes: getSizeMetas :: TCM [(MetaId, Int)]

- Agda.TypeChecking.SizedTypes: haveSizedTypes :: MonadTCM tcm => tcm Bool

+ Agda.TypeChecking.SizedTypes: haveSizedTypes :: TCM Bool

- Agda.TypeChecking.SizedTypes: sizeExpr :: MonadTCM tcm => Term -> tcm (SizeExpr, Int)

+ Agda.TypeChecking.SizedTypes: sizeExpr :: Term -> TCM (SizeExpr, Int)

- Agda.TypeChecking.SizedTypes: solveSizeConstraints :: MonadTCM tcm => tcm ()

+ Agda.TypeChecking.SizedTypes: solveSizeConstraints :: TCM ()

- Agda.TypeChecking.SizedTypes: trivial :: MonadTCM tcm => Term -> Term -> tcm Bool

+ Agda.TypeChecking.SizedTypes: trivial :: Term -> Term -> TCM Bool

- Agda.TypeChecking.Substitute: TelV :: Telescope -> Type -> TelView

+ Agda.TypeChecking.Substitute: TelV :: (Tele (Arg a)) -> a -> TelV a

- Agda.TypeChecking.Telescope: piApplyM :: MonadTCM tcm => Type -> Args -> tcm Type

+ Agda.TypeChecking.Telescope: piApplyM :: Type -> Args -> TCM Type

- Agda.TypeChecking.Telescope: reorderTel :: [Arg Type] -> Permutation

+ Agda.TypeChecking.Telescope: reorderTel :: [Arg Type] -> Maybe Permutation

- Agda.TypeChecking.Telescope: splitTelescope :: Set Nat -> Telescope -> SplitTel

+ Agda.TypeChecking.Telescope: splitTelescope :: VarSet -> Telescope -> SplitTel

- Agda.TypeChecking.Telescope: telView :: MonadTCM tcm => Type -> tcm TelView

+ Agda.TypeChecking.Telescope: telView :: Type -> TCM TelView

- Agda.TypeChecking.Telescope: telViewUpTo :: MonadTCM tcm => Int -> Type -> tcm TelView

+ Agda.TypeChecking.Telescope: telViewUpTo :: Int -> Type -> TCM TelView

- Agda.TypeChecking.UniversePolymorphism: compareLevel :: MonadTCM tcm => Comparison -> Term -> Term -> tcm Constraints

+ Agda.TypeChecking.UniversePolymorphism: compareLevel :: Comparison -> Level -> Level -> TCM ()

- Agda.TypeChecking.With: patsToTerms :: [Arg Pattern] -> [Arg Term]

+ Agda.TypeChecking.With: patsToTerms :: [Arg Pattern] -> [Arg DisplayTerm]

- Agda.Utils.Graph: transitiveClosure :: (SemiRing e, Ord n) => Graph n e -> Graph n e

+ Agda.Utils.Graph: transitiveClosure :: (Eq e, SemiRing e, Ord n) => Graph n e -> Graph n e

- Agda.Utils.String: showIndex :: Integral i => i -> String

+ Agda.Utils.String: showIndex :: (Show i, Integral i) => i -> String

Files

Agda.cabal +49/−24
README +1/−4
dist/build/Agda/Syntax/Parser/Lexer.hs +99/−92
dist/build/Agda/Syntax/Parser/Parser.hs +4993/−4197
doc/release-notes/2-3-0.txt +1005/−0
src/data/EpicInclude/AgdaPrelude.e +151/−39
src/data/EpicInclude/stdagda.c +62/−11
src/data/EpicInclude/stdagda.h +22/−2
src/data/emacs-mode/agda-input.el +43/−2
src/data/emacs-mode/agda2-highlight.el +5/−3
src/data/emacs-mode/agda2-mode.el +74/−23
src/data/emacs-mode/annotation.el +11/−4
src/full/Agda/Auto/Auto.hs +16/−14
src/full/Agda/Auto/CaseSplit.hs +1/−1
src/full/Agda/Auto/Convert.hs +67/−65
src/full/Agda/Auto/Syntax.hs +1/−0
src/full/Agda/Compiler/Epic/AuxAST.hs +58/−8
src/full/Agda/Compiler/Epic/CaseOpts.hs +42/−0
src/full/Agda/Compiler/Epic/CompileState.hs +139/−59
src/full/Agda/Compiler/Epic/Compiler.hs +180/−61
src/full/Agda/Compiler/Epic/ConstructorIrrelevancy.hs +0/−67
src/full/Agda/Compiler/Epic/Epic.hs +44/−13
src/full/Agda/Compiler/Epic/Erasure.hs +130/−48
src/full/Agda/Compiler/Epic/ForceConstrs.hs +75/−0
src/full/Agda/Compiler/Epic/Forcing.hs +217/−306
src/full/Agda/Compiler/Epic/FromAgda.hs +82/−58
src/full/Agda/Compiler/Epic/Injection.hs +323/−0
src/full/Agda/Compiler/Epic/Interface.hs +87/−0
src/full/Agda/Compiler/Epic/LambdaLift.hs +0/−60
src/full/Agda/Compiler/Epic/NatDetection.hs +37/−24
src/full/Agda/Compiler/Epic/Primitive.hs +76/−66
src/full/Agda/Compiler/Epic/Smashing.hs +135/−0
src/full/Agda/Compiler/Epic/Static.hs +101/−0
src/full/Agda/Compiler/HaskellTypes.hs +29/−26
src/full/Agda/Compiler/JS/Case.hs +127/−0
src/full/Agda/Compiler/JS/Compiler.hs +448/−0
src/full/Agda/Compiler/JS/Parser.hs +187/−0
src/full/Agda/Compiler/JS/Pretty.hs +118/−0
src/full/Agda/Compiler/JS/Substitution.hs +124/−0
src/full/Agda/Compiler/JS/Syntax.hs +110/−0
src/full/Agda/Compiler/MAlonzo/Compiler.hs +68/−43
src/full/Agda/Compiler/MAlonzo/Misc.hs +11/−5
src/full/Agda/Compiler/MAlonzo/Primitives.hs +15/−10
src/full/Agda/Interaction/BasicOps.hs +96/−129
src/full/Agda/Interaction/CommandLine/CommandLine.hs +7/−13
src/full/Agda/Interaction/EmacsCommand.hs +45/−0
src/full/Agda/Interaction/GhciTop.hs +101/−68
src/full/Agda/Interaction/Highlighting/Dot.hs +90/−0
src/full/Agda/Interaction/Highlighting/Emacs.hs +0/−1
src/full/Agda/Interaction/Highlighting/Generate.hs +47/−52
src/full/Agda/Interaction/Imports.hs +29/−10
src/full/Agda/Interaction/Imports.hs-boot +0/−1
src/full/Agda/Interaction/MakeCase.hs +20/−12
src/full/Agda/Interaction/Monad.hs +2/−1
src/full/Agda/Interaction/Options.hs +63/−19
src/full/Agda/Main.hs +7/−10
src/full/Agda/Syntax/Abstract.hs +166/−97
src/full/Agda/Syntax/Abstract/Name.hs +3/−0
src/full/Agda/Syntax/Abstract/Pretty.hs +4/−4
src/full/Agda/Syntax/Abstract/Views.hs +9/−27
src/full/Agda/Syntax/Common.hs +36/−41
src/full/Agda/Syntax/Concrete.hs +110/−14
src/full/Agda/Syntax/Concrete/Definitions.hs +505/−328
src/full/Agda/Syntax/Concrete/Name.hs +4/−0
src/full/Agda/Syntax/Concrete/Operators.hs +30/−5
src/full/Agda/Syntax/Concrete/Operators/Parser.hs +23/−10
src/full/Agda/Syntax/Concrete/Pretty.hs +106/−20
src/full/Agda/Syntax/Fixity.hs +16/−8
src/full/Agda/Syntax/Internal.hs +113/−157
src/full/Agda/Syntax/Internal/Generic.hs +67/−30
src/full/Agda/Syntax/Literal.hs +0/−8
src/full/Agda/Syntax/Notation.hs +4/−0
src/full/Agda/Syntax/Parser/Alex.hs +14/−1
src/full/Agda/Syntax/Parser/LexActions.hs +8/−6
src/full/Agda/Syntax/Parser/LexActions.hs-boot +0/−1
src/full/Agda/Syntax/Parser/Lexer.x +19/−4
src/full/Agda/Syntax/Parser/Parser.y +317/−89
src/full/Agda/Syntax/Parser/Tokens.hs +5/−3
src/full/Agda/Syntax/Position.hs +3/−1
src/full/Agda/Syntax/Scope/Base.hs +89/−72
src/full/Agda/Syntax/Scope/Monad.hs +21/−23
src/full/Agda/Syntax/Strict.hs +28/−15
src/full/Agda/Syntax/Translation/AbstractToConcrete.hs +153/−108
src/full/Agda/Syntax/Translation/ConcreteToAbstract.hs +286/−165
src/full/Agda/Syntax/Translation/InternalToAbstract.hs +181/−67
src/full/Agda/Termination/SparseMatrix.hs +6/−6
src/full/Agda/Termination/TermCheck.hs +127/−68
src/full/Agda/TypeChecking/Abstract.hs +27/−10
src/full/Agda/TypeChecking/CompiledClause.hs +11/−58
src/full/Agda/TypeChecking/CompiledClause/Compile.hs +124/−0
src/full/Agda/TypeChecking/CompiledClause/Compile.hs-boot +7/−0
src/full/Agda/TypeChecking/CompiledClause/Match.hs +49/−36
src/full/Agda/TypeChecking/CompiledClause/Match.hs-boot +0/−1
src/full/Agda/TypeChecking/Constraints.hs +206/−70
src/full/Agda/TypeChecking/Conversion.hs +454/−370
src/full/Agda/TypeChecking/Conversion.hs-boot +11/−12
src/full/Agda/TypeChecking/Coverage.hs +71/−62
src/full/Agda/TypeChecking/Coverage/Match.hs +7/−12
src/full/Agda/TypeChecking/Datatypes.hs +12/−3
src/full/Agda/TypeChecking/Datatypes.hs-boot +1/−2
src/full/Agda/TypeChecking/DisplayForm.hs +3/−2
src/full/Agda/TypeChecking/Eliminators.hs +71/−0
src/full/Agda/TypeChecking/Empty.hs +17/−10
src/full/Agda/TypeChecking/Empty.hs-boot +3/−4
src/full/Agda/TypeChecking/Errors.hs +71/−52
src/full/Agda/TypeChecking/EtaContract.hs +16/−8
src/full/Agda/TypeChecking/Forcing.hs +4/−4
src/full/Agda/TypeChecking/Free.hs +120/−31
src/full/Agda/TypeChecking/Implicit.hs +21/−17
src/full/Agda/TypeChecking/Injectivity.hs +37/−11
src/full/Agda/TypeChecking/Irrelevance.hs +161/−0
src/full/Agda/TypeChecking/Level.hs +42/−76
src/full/Agda/TypeChecking/Level.hs-boot +7/−0
src/full/Agda/TypeChecking/LevelConstraints.hs +34/−0
src/full/Agda/TypeChecking/MetaVars.hs +329/−312
src/full/Agda/TypeChecking/MetaVars.hs-boot +5/−6
src/full/Agda/TypeChecking/MetaVars/Mention.hs +105/−0
src/full/Agda/TypeChecking/MetaVars/Occurs.hs +225/−85
src/full/Agda/TypeChecking/Monad/Base.hs +274/−145
src/full/Agda/TypeChecking/Monad/Builtin.hs +71/−30
src/full/Agda/TypeChecking/Monad/Closure.hs +1/−1
src/full/Agda/TypeChecking/Monad/Constraints.hs +115/−25
src/full/Agda/TypeChecking/Monad/Context.hs +52/−20
src/full/Agda/TypeChecking/Monad/Context.hs-boot +0/−1
src/full/Agda/TypeChecking/Monad/Env.hs +13/−6
src/full/Agda/TypeChecking/Monad/Exception.hs +12/−0
src/full/Agda/TypeChecking/Monad/Imports.hs +15/−13
src/full/Agda/TypeChecking/Monad/MetaVars.hs +56/−29
src/full/Agda/TypeChecking/Monad/Mutual.hs +8/−8
src/full/Agda/TypeChecking/Monad/Open.hs +4/−4
src/full/Agda/TypeChecking/Monad/Options.hs +69/−53
src/full/Agda/TypeChecking/Monad/Options.hs-boot +1/−1
src/full/Agda/TypeChecking/Monad/Signature.hs +225/−105
src/full/Agda/TypeChecking/Monad/SizedTypes.hs +26/−5
src/full/Agda/TypeChecking/Monad/State.hs +38/−18
src/full/Agda/TypeChecking/Monad/Statistics.hs +13/−5
src/full/Agda/TypeChecking/Monad/Trace.hs +7/−3
src/full/Agda/TypeChecking/Patterns/Match.hs +3/−3
src/full/Agda/TypeChecking/Patterns/Match.hs-boot +1/−2
src/full/Agda/TypeChecking/Polarity.hs +19/−4
src/full/Agda/TypeChecking/Polarity.hs-boot +0/−1
src/full/Agda/TypeChecking/Positivity.hs +43/−30
src/full/Agda/TypeChecking/Pretty.hs +33/−27
src/full/Agda/TypeChecking/Pretty.hs-boot +26/−0
src/full/Agda/TypeChecking/Primitive.hs +147/−55
src/full/Agda/TypeChecking/Quote.hs +202/−18
src/full/Agda/TypeChecking/Rebind.hs +1/−14
src/full/Agda/TypeChecking/RecordPatterns.hs +46/−66
src/full/Agda/TypeChecking/Records.hs +52/−23
src/full/Agda/TypeChecking/Records.hs-boot +5/−5
src/full/Agda/TypeChecking/Reduce.hs +263/−178
src/full/Agda/TypeChecking/Rules/Builtin.hs +206/−244
src/full/Agda/TypeChecking/Rules/Builtin/Coinduction.hs +23/−48
src/full/Agda/TypeChecking/Rules/Data.hs +67/−37
src/full/Agda/TypeChecking/Rules/Decl.hs +119/−49
src/full/Agda/TypeChecking/Rules/Decl.hs-boot +2/−3
src/full/Agda/TypeChecking/Rules/Def.hs +50/−34
src/full/Agda/TypeChecking/Rules/Def.hs-boot +3/−0
src/full/Agda/TypeChecking/Rules/LHS.hs +12/−16
src/full/Agda/TypeChecking/Rules/LHS/Implicit.hs +6/−4
src/full/Agda/TypeChecking/Rules/LHS/Instantiate.hs +12/−3
src/full/Agda/TypeChecking/Rules/LHS/Problem.hs +4/−0
src/full/Agda/TypeChecking/Rules/LHS/Split.hs +50/−17
src/full/Agda/TypeChecking/Rules/LHS/Unify.hs +747/−52
src/full/Agda/TypeChecking/Rules/Record.hs +128/−62
src/full/Agda/TypeChecking/Rules/Term.hs +603/−363
src/full/Agda/TypeChecking/Rules/Term.hs-boot +0/−1
src/full/Agda/TypeChecking/Serialise.hs +306/−171
src/full/Agda/TypeChecking/SizedTypes.hs +20/−23
src/full/Agda/TypeChecking/Substitute.hs +425/−89
src/full/Agda/TypeChecking/Telescope.hs +20/−32
src/full/Agda/TypeChecking/Test/Generators.hs +17/−21
src/full/Agda/TypeChecking/Tests.hs +2/−2
src/full/Agda/TypeChecking/UniversePolymorphism.hs +4/−63
src/full/Agda/TypeChecking/UniversePolymorphism.hs-boot +1/−2
src/full/Agda/TypeChecking/With.hs +35/−50
src/full/Agda/Utils/FileName.hs +1/−1
src/full/Agda/Utils/Generics.hs +13/−2
src/full/Agda/Utils/Graph.hs +10/−4
src/full/Agda/Utils/IO/UTF8.hs +15/−2
src/full/Agda/Utils/List.hs +41/−0
src/full/Agda/Utils/Monad.hs +4/−8
src/full/Agda/Utils/ReadP.hs +16/−1
src/full/Agda/Utils/Size.hs +4/−0
src/full/Agda/Utils/String.hs +1/−1
src/full/Agda/Utils/VarSet.hs +54/−0

Agda.cabal view

@@ -1,6 +1,6 @@ name:            Agda-version:         2.2.10-cabal-version:   >= 1.8 && < 2+version:         2.3.0+cabal-version:   >= 1.8 build-type:      Simple license:         OtherLicense license-file:    LICENSE@@ -34,7 +34,7 @@   Note also that this library does not follow the package versioning   policy, because the library is only intended to be used by the Emacs   mode and the Agda-executable package.-tested-with:        GHC == 6.12.1, GHC == 6.12.3, GHC == 7.0.1+tested-with:        GHC == 7.2.2 extra-source-files: src/full/Agda/undefined.h                     README                     doc/release-notes/*.txt@@ -52,7 +52,7 @@ source-repository this   type:     darcs   location: http://code.haskell.org/Agda/-  tag:      2.2.10+  tag:      2.3.0  flag use-locale   description:@@ -69,30 +69,32 @@ library   hs-source-dirs:   src/full   if flag(use-locale)-    build-depends:  base >= 4.2 && < 4.4+    build-depends:  base >= 4.2 && < 4.5   else     build-depends:  base == 4.1.*,                     utf8-string == 0.3.*   if flag(epic)-    build-depends:  epic >= 0.1.7 && < 0.2+    build-depends:  epic >= 0.1.13 && < 0.2   build-depends:    mtl == 2.0.*,                     QuickCheck >= 2.3 && < 2.5,-                    haskell-src-exts >= 1.9.6 && < 1.10,-                    containers >= 0.1.0 && < 1,-                    pretty >= 1 && < 2,+                    haskell-src-exts >= 1.9.6 && < 1.12,+                    containers >= 0.1 && < 0.5,+                    pretty >= 1.0 && < 1.2,                     directory >= 1.0 && < 1.2,-                    old-time >= 1 && < 2,-                    bytestring >= 0.9.0.1 && < 1,-                    array >= 0.1 && < 1,+                    old-time == 1.0.*,+                    bytestring >= 0.9.0.1 && < 0.10,+                    array >= 0.1 && < 0.4,                     binary >= 0.4.4 && < 0.6,-                    zlib >= 0.4.0.1 && < 1,-                    filepath >= 1.1 && < 2,-                    process >= 1.0.1.0 && < 2,+                    zlib >= 0.4.0.1 && < 0.6,+                    filepath >= 1.1 && < 1.3,+                    process >= 1.0.1.0 && < 1.2,                     haskeline >= 0.6.3.2 && < 0.7,                     xhtml == 3000.2.*,-                    syb >= 0.1 && < 0.3+                    hashable == 1.1.*,+                    hashtables == 1.0.*,+                    syb >= 0.1 && < 0.4   build-tools:      happy >= 1.15 && < 2,-                    alex >= 2.0.1 && < 3+                    alex >= 2.3.1 && < 3.1   extensions:       CPP   exposed-modules:  Agda.Main                     Agda.ImpossibleTest@@ -100,16 +102,26 @@                     Agda.Interaction.GhciTop                     Agda.Compiler.HaskellTypes                     Agda.Compiler.Epic.AuxAST+                    Agda.Compiler.Epic.CaseOpts                     Agda.Compiler.Epic.Compiler                     Agda.Compiler.Epic.CompileState-                    Agda.Compiler.Epic.ConstructorIrrelevancy-                    Agda.Compiler.Epic.Erasure                     Agda.Compiler.Epic.Epic+                    Agda.Compiler.Epic.Erasure+                    Agda.Compiler.Epic.ForceConstrs                     Agda.Compiler.Epic.Forcing                     Agda.Compiler.Epic.FromAgda-                    Agda.Compiler.Epic.LambdaLift+                    Agda.Compiler.Epic.Injection+                    Agda.Compiler.Epic.Interface                     Agda.Compiler.Epic.NatDetection                     Agda.Compiler.Epic.Primitive+                    Agda.Compiler.Epic.Smashing+                    Agda.Compiler.Epic.Static+                    Agda.Compiler.JS.Case+                    Agda.Compiler.JS.Compiler+                    Agda.Compiler.JS.Syntax+                    Agda.Compiler.JS.Substitution+                    Agda.Compiler.JS.Parser+                    Agda.Compiler.JS.Pretty                     Agda.Compiler.MAlonzo.Compiler                     Agda.Compiler.MAlonzo.Encode                     Agda.Compiler.MAlonzo.Misc@@ -120,8 +132,10 @@                     Agda.Packaging.Monad                     Agda.Packaging.Types                     Agda.Interaction.CommandLine.CommandLine+                    Agda.Interaction.EmacsCommand                     Agda.Interaction.Exceptions                     Agda.Interaction.FindFile+                    Agda.Interaction.Highlighting.Dot                     Agda.Interaction.Highlighting.Emacs                     Agda.Interaction.Highlighting.Generate                     Agda.Interaction.Highlighting.HTML@@ -179,6 +193,7 @@                     Agda.TypeChecker                     Agda.TypeChecking.Abstract                     Agda.TypeChecking.CompiledClause+                    Agda.TypeChecking.CompiledClause.Compile                     Agda.TypeChecking.CompiledClause.Match                     Agda.TypeChecking.Constraints                     Agda.TypeChecking.Conversion@@ -186,6 +201,7 @@                     Agda.TypeChecking.Coverage.Match                     Agda.TypeChecking.Datatypes                     Agda.TypeChecking.DisplayForm+                    Agda.TypeChecking.Eliminators                     Agda.TypeChecking.Empty                     Agda.TypeChecking.EtaContract                     Agda.TypeChecking.Errors@@ -193,8 +209,11 @@                     Agda.TypeChecking.Forcing                     Agda.TypeChecking.Implicit                     Agda.TypeChecking.Injectivity+                    Agda.TypeChecking.Irrelevance                     Agda.TypeChecking.Level+                    Agda.TypeChecking.LevelConstraints                     Agda.TypeChecking.MetaVars+                    Agda.TypeChecking.MetaVars.Mention                     Agda.TypeChecking.MetaVars.Occurs                     Agda.TypeChecking.Monad.Base                     Agda.TypeChecking.Monad.Builtin@@ -246,6 +265,7 @@                     Agda.TypeChecking.Tests                     Agda.TypeChecking.UniversePolymorphism                     Agda.TypeChecking.With+                    Agda.Utils.VarSet                     Agda.Utils.Char                     Agda.Utils.Either                     Agda.Utils.FileName@@ -286,7 +306,7 @@                     Agda.Auto.CaseSplit   other-modules:    Paths_Agda   if true-    ghc-options:    -w -Werror+    ghc-options:    -w                     -fwarn-deprecated-flags                     -fwarn-dodgy-foreign-imports                     -fwarn-dodgy-imports@@ -297,9 +317,14 @@                     -fwarn-missing-methods                     -fwarn-overlapping-patterns                     -fwarn-warnings-deprecations+  -- The Cabal-generated module Paths_Agda triggers a warning under+  -- GHC 7.2.1/7.2.2 (at least when certain versions of Cabal are+  -- used).   if impl(ghc >= 6.12)     ghc-options:    -fwarn-dodgy-exports                     -fwarn-wrong-do-bind+  if impl(ghc >= 7.2)+    ghc-options:    -fwarn-identities   ghc-prof-options: -auto-all  executable agda-mode@@ -307,10 +332,10 @@   main-is:          Main.hs   other-modules:    Paths_Agda   if flag(use-locale)-    build-depends:  base >= 4.2 && < 4.4+    build-depends:  base >= 4.2 && < 4.5   else     build-depends:  base == 4.1.*,                     utf8-string == 0.3.*-  build-depends:    filepath >= 1.1 && < 2,-                    process >= 1.0.1.0 && < 2,+  build-depends:    filepath >= 1.1 && < 1.3,+                    process >= 1.0.1.0 && < 1.2,                     directory >= 1.0 && < 1.2

README view

@@ -160,10 +160,7 @@ * When installing using a source tar ball, following the instructions   in 2b) above: -    make CABAL_OPTIONS="--global -fepic" install--  (The Makefile specifies CABAL_OPTIONS=--global by default; feel free-  to omit --global.)+    make CABAL_OPTIONS=-fepic install  You can also install Epic directly:

dist/build/Agda/Syntax/Parser/Lexer.hs view

@@ -1,7 +1,8 @@-{-# OPTIONS -fglasgow-exts -cpp #-}+{-# LANGUAGE CPP,MagicHash #-} {-# LINE 1 "src/full/Agda/Syntax/Parser/Lexer.x" #-}  {-# OPTIONS_GHC -fno-warn-deprecated-flags #-}+{-# LANGUAGE BangPatterns #-} {-| The lexer is generated by Alex (<http://www.haskell.org/alex>) and is an     adaptation of GHC's lexer. The main lexing function 'lexer' is called by     the "Agda.Syntax.Parser.Parser" to get the next token from the input.@@ -49,19 +50,19 @@ import GlaExts #endif alex_base :: AlexAddr-alex_base = AlexA# "\xf7\xff\xff\xff\x6c\x00\x00\x00\xc8\x00\x00\x00\x3c\x01\x00\x00\x40\x01\x00\x00\x44\x01\x00\x00\x4b\x01\x00\x00\x70\x00\x00\x00\x74\x00\x00\x00\x78\x00\x00\x00\x7c\x00\x00\x00\x7d\x00\x00\x00\x81\x00\x00\x00\x48\x01\x00\x00\x49\x01\x00\x00\x4f\x01\x00\x00\x50\x01\x00\x00\x53\x01\x00\x00\x51\x01\x00\x00\x54\x01\x00\x00\x55\x01\x00\x00\x57\x01\x00\x00\xfb\xff\xff\xff\x00\x00\x00\x00\xfc\xff\xff\xff\xfd\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\xff\xff\xff\x9b\xff\xff\xff\xa6\xff\xff\xff\x90\xff\xff\xff\xa9\xff\xff\xff\x9e\xff\xff\xff\xaa\xff\xff\xff\xab\xff\xff\xff\x92\xff\xff\xff\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x71\x00\x00\x00\xee\xff\xff\xff\x9a\x00\x00\x00\xa0\x00\x00\x00\xa6\x00\x00\x00\xab\x00\x00\x00\xb8\x00\x00\x00\x69\x01\x00\x00\x6f\x01\x00\x00\x75\x01\x00\x00\x7b\x01\x00\x00\x99\x01\x00\x00\x9e\x01\x00\x00\xcc\x01\x00\x00\xd1\x01\x00\x00\xde\x01\x00\x00\xe9\x01\x00\x00\xee\x01\x00\x00\xf6\x01\x00\x00\xfb\x01\x00\x00\x07\x02\x00\x00\x13\x02\x00\x00\x1f\x02\x00\x00\x24\x02\x00\x00\x3c\x02\x00\x00\x48\x02\x00\x00\x4d\x02\x00\x00\x59\x02\x00\x00\x65\x02\x00\x00\x6b\x02\x00\x00\x71\x02\x00\x00\x77\x02\x00\x00\x83\x02\x00\x00\x90\x02\x00\x00\x95\x02\x00\x00\xad\x02\x00\x00\xb4\x02\x00\x00\xbc\x02\x00\x00\xce\x02\x00\x00\xd4\x02\x00\x00\xdc\x02\x00\x00\xe6\x02\x00\x00\xee\x02\x00\x00\xf4\x02\x00\x00\xfe\x02\x00\x00\x0d\x03\x00\x00\x16\x03\x00\x00\x1b\x03\x00\x00\x33\x03\x00\x00\x38\x03\x00\x00\x43\x03\x00\x00\x55\x03\x00\x00\x5d\x03\x00\x00\x66\x03\x00\x00\x6e\x03\x00\x00\x75\x03\x00\x00\x80\x03\x00\x00\x86\x03\x00\x00\x8e\x03\x00\x00\x98\x03\x00\x00\x9e\x03\x00\x00\xb0\x03\x00\x00\xb6\x03\x00\x00\x00\x00\x00\x00\xe5\xff\xff\xff\x09\x00\x00\x00\xcd\x03\x00\x00\x0a\x00\x00\x00\x3e\x04\x00\x00\xaf\x04\x00\x00\x20\x05\x00\x00\x91\x05\x00\x00\x02\x06\x00\x00\x5e\x06\x00\x00\xe8\xff\xff\xff\xba\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x07\x00\x00\x72\x07\x00\x00\xce\x07\x00\x00\x2a\x08\x00\x00\x86\x08\x00\x00\xe2\x08\x00\x00\x3e\x09\x00\x00\x9a\x09\x00\x00\xf6\x09\x00\x00\x52\x0a\x00\x00\xae\x0a\x00\x00\x0a\x0b\x00\x00\x66\x0b\x00\x00\xc2\x0b\x00\x00\x1e\x0c\x00\x00\x7a\x0c\x00\x00\xd6\x0c\x00\x00\x32\x0d\x00\x00\x8e\x0d\x00\x00\xea\x0d\x00\x00\x46\x0e\x00\x00\xa2\x0e\x00\x00\xfe\x0e\x00\x00\x5a\x0f\x00\x00\xb6\x0f\x00\x00\x12\x10\x00\x00\x6e\x10\x00\x00\xca\x10\x00\x00\x26\x11\x00\x00\x82\x11\x00\x00\xde\x11\x00\x00\x3a\x12\x00\x00\x96\x12\x00\x00\xf2\x12\x00\x00\x4e\x13\x00\x00\xaa\x13\x00\x00\x06\x14\x00\x00\x62\x14\x00\x00\xbe\x14\x00\x00\x1a\x15\x00\x00\x76\x15\x00\x00\xd2\x15\x00\x00\x2e\x16\x00\x00\x8a\x16\x00\x00\xe6\x16\x00\x00\x42\x17\x00\x00\x9e\x17\x00\x00\xfa\x17\x00\x00\x56\x18\x00\x00\xb2\x18\x00\x00\x0e\x19\x00\x00\x6a\x19\x00\x00\xc6\x19\x00\x00\x22\x1a\x00\x00\x7e\x1a\x00\x00\xda\x1a\x00\x00\x36\x1b\x00\x00\x92\x1b\x00\x00\xee\x1b\x00\x00\x4a\x1c\x00\x00\xa6\x1c\x00\x00\x02\x1d\x00\x00\x5e\x1d\x00\x00\xba\x1d\x00\x00\x16\x1e\x00\x00\x72\x1e\x00\x00\xce\x1e\x00\x00\x2a\x1f\x00\x00\x86\x1f\x00\x00\xe2\x1f\x00\x00\x3e\x20\x00\x00\x9a\x20\x00\x00\xf6\x20\x00\x00\x52\x21\x00\x00\xae\x21\x00\x00\x0a\x22\x00\x00\x66\x22\x00\x00\xc2\x22\x00\x00\x1e\x23\x00\x00\x7a\x23\x00\x00\xd6\x23\x00\x00\x32\x24\x00\x00\x8e\x24\x00\x00\xea\x24\x00\x00\x46\x25\x00\x00\xa2\x25\x00\x00\xfe\x25\x00\x00\x5a\x26\x00\x00\xb6\x26\x00\x00\x12\x27\x00\x00\x6e\x27\x00\x00\xca\x27\x00\x00\x26\x28\x00\x00\x82\x28\x00\x00\xde\x28\x00\x00\x3a\x29\x00\x00\x96\x29\x00\x00\xf2\x29\x00\x00\x4e\x2a\x00\x00\xaa\x2a\x00\x00\x06\x2b\x00\x00\x62\x2b\x00\x00\xbe\x2b\x00\x00\x1a\x2c\x00\x00\x76\x2c\x00\x00\xd2\x2c\x00\x00\x2e\x2d\x00\x00\x8a\x2d\x00\x00\xe6\x2d\x00\x00\x42\x2e\x00\x00\x9e\x2e\x00\x00\xfa\x2e\x00\x00\x56\x2f\x00\x00\xb2\x2f\x00\x00\x0e\x30\x00\x00\x6a\x30\x00\x00\xc6\x30\x00\x00\x22\x31\x00\x00\x7e\x31\x00\x00\xda\x31\x00\x00\x36\x32\x00\x00\x92\x32\x00\x00\xee\x32\x00\x00\x4a\x33\x00\x00\xa6\x33\x00\x00\x02\x34\x00\x00\x5e\x34\x00\x00\xba\x34\x00\x00\x16\x35\x00\x00\x72\x35\x00\x00\xce\x35\x00\x00\x2a\x36\x00\x00\x86\x36\x00\x00\xe2\x36\x00\x00\x3e\x37\x00\x00\x9a\x37\x00\x00\xf6\x37\x00\x00\x52\x38\x00\x00\xae\x38\x00\x00\x0a\x39\x00\x00\x66\x39\x00\x00\xc2\x39\x00\x00\x1e\x3a\x00\x00\x7a\x3a\x00\x00\xd6\x3a\x00\x00\x32\x3b\x00\x00\x8e\x3b\x00\x00\xea\x3b\x00\x00\x46\x3c\x00\x00\xa2\x3c\x00\x00\x00\x00\x00\x00\xa7\xff\xff\xff\xfe\x3c\x00\x00\x5a\x3d\x00\x00\xb6\x3d\x00\x00\x12\x3e\x00\x00\x6e\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x63\x00\x00\x00\x65\x00\x00\x00\x00\x00\x00\x00\xca\x3e\x00\x00\x26\x3f\x00\x00\x82\x3f\x00\x00\xde\x3f\x00\x00\x3a\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x96\x40\x00\x00\xf2\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4e\x41\x00\x00\xaa\x41\x00\x00\x06\x42\x00\x00\x62\x42\x00\x00\xbe\x42\x00\x00\x1a\x43\x00\x00\x76\x43\x00\x00\xd2\x43\x00\x00\x2e\x44\x00\x00\x8a\x44\x00\x00\xe6\x44\x00\x00\x42\x45\x00\x00\x9e\x45\x00\x00\xfa\x45\x00\x00\x56\x46\x00\x00\xb2\x46\x00\x00\x0e\x47\x00\x00\x6a\x47\x00\x00\xc6\x47\x00\x00\x22\x48\x00\x00\x7e\x48\x00\x00\xda\x48\x00\x00\x36\x49\x00\x00\x92\x49\x00\x00\xee\x49\x00\x00\x4a\x4a\x00\x00\xa6\x4a\x00\x00\x02\x4b\x00\x00\x5e\x4b\x00\x00\xba\x4b\x00\x00\x16\x4c\x00\x00\x72\x4c\x00\x00\xce\x4c\x00\x00\x2a\x4d\x00\x00\x86\x4d\x00\x00"#+alex_base = AlexA# "\xf7\xff\xff\xff\x6c\x00\x00\x00\xc8\x00\x00\x00\x3c\x01\x00\x00\x40\x01\x00\x00\x44\x01\x00\x00\x4b\x01\x00\x00\x70\x00\x00\x00\x74\x00\x00\x00\x78\x00\x00\x00\x7c\x00\x00\x00\x7d\x00\x00\x00\x81\x00\x00\x00\x48\x01\x00\x00\x49\x01\x00\x00\x4f\x01\x00\x00\x50\x01\x00\x00\x53\x01\x00\x00\x51\x01\x00\x00\x54\x01\x00\x00\x55\x01\x00\x00\x57\x01\x00\x00\xfb\xff\xff\xff\x00\x00\x00\x00\xfc\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xa2\xff\xff\xff\x9a\xff\xff\xff\xa5\xff\xff\xff\x8f\xff\xff\xff\xa8\xff\xff\xff\x9d\xff\xff\xff\xa9\xff\xff\xff\xaa\xff\xff\xff\x91\xff\xff\xff\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x46\x01\x00\x00\xed\xff\xff\xff\x9a\x00\x00\x00\xa0\x00\x00\x00\xa6\x00\x00\x00\xab\x00\x00\x00\xb8\x00\x00\x00\x6b\x01\x00\x00\x71\x01\x00\x00\x78\x01\x00\x00\x7d\x01\x00\x00\x99\x01\x00\x00\x9e\x01\x00\x00\xc3\x01\x00\x00\xcc\x01\x00\x00\xd1\x01\x00\x00\xe9\x01\x00\x00\xee\x01\x00\x00\xf3\x01\x00\x00\xf8\x01\x00\x00\x10\x02\x00\x00\x18\x02\x00\x00\x1d\x02\x00\x00\x22\x02\x00\x00\x28\x02\x00\x00\x3a\x02\x00\x00\x44\x02\x00\x00\x49\x02\x00\x00\x52\x02\x00\x00\x61\x02\x00\x00\x6e\x02\x00\x00\x73\x02\x00\x00\x79\x02\x00\x00\x91\x02\x00\x00\x96\x02\x00\x00\x9e\x02\x00\x00\xa3\x02\x00\x00\xbf\x02\x00\x00\xc6\x02\x00\x00\xcf\x02\x00\x00\xd7\x02\x00\x00\xdf\x02\x00\x00\xe7\x02\x00\x00\xf7\x02\x00\x00\x09\x03\x00\x00\x0f\x03\x00\x00\x14\x03\x00\x00\x19\x03\x00\x00\x31\x03\x00\x00\x36\x03\x00\x00\x3b\x03\x00\x00\x40\x03\x00\x00\x58\x03\x00\x00\x60\x03\x00\x00\x66\x03\x00\x00\x70\x03\x00\x00\x7e\x03\x00\x00\x88\x03\x00\x00\x8d\x03\x00\x00\x96\x03\x00\x00\xae\x03\x00\x00\xb3\x03\x00\x00\xbb\x03\x00\x00\xcb\x03\x00\x00\xd8\x03\x00\x00\xdd\x03\x00\x00\xe8\x03\x00\x00\xf8\x03\x00\x00\x00\x04\x00\x00\x05\x04\x00\x00\x0a\x04\x00\x00\x00\x00\x00\x00\xe4\xff\xff\xff\x08\x00\x00\x00\x2c\x04\x00\x00\x09\x00\x00\x00\x9d\x04\x00\x00\x0e\x05\x00\x00\x7f\x05\x00\x00\xf0\x05\x00\x00\x61\x06\x00\x00\xbd\x06\x00\x00\xe7\xff\xff\xff\x19\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x75\x07\x00\x00\xd1\x07\x00\x00\x2d\x08\x00\x00\x89\x08\x00\x00\xe5\x08\x00\x00\x41\x09\x00\x00\x9d\x09\x00\x00\xf9\x09\x00\x00\x55\x0a\x00\x00\xb1\x0a\x00\x00\x0d\x0b\x00\x00\x69\x0b\x00\x00\xc5\x0b\x00\x00\x21\x0c\x00\x00\x7d\x0c\x00\x00\xd9\x0c\x00\x00\x35\x0d\x00\x00\x91\x0d\x00\x00\xed\x0d\x00\x00\x49\x0e\x00\x00\xa5\x0e\x00\x00\x01\x0f\x00\x00\x5d\x0f\x00\x00\xb9\x0f\x00\x00\x15\x10\x00\x00\x71\x10\x00\x00\xcd\x10\x00\x00\x29\x11\x00\x00\x85\x11\x00\x00\xe1\x11\x00\x00\x3d\x12\x00\x00\x99\x12\x00\x00\xf5\x12\x00\x00\x51\x13\x00\x00\xad\x13\x00\x00\x09\x14\x00\x00\x65\x14\x00\x00\xc1\x14\x00\x00\x1d\x15\x00\x00\x79\x15\x00\x00\xd5\x15\x00\x00\x31\x16\x00\x00\x8d\x16\x00\x00\xe9\x16\x00\x00\x45\x17\x00\x00\xa1\x17\x00\x00\xfd\x17\x00\x00\x59\x18\x00\x00\xb5\x18\x00\x00\x11\x19\x00\x00\x6d\x19\x00\x00\xc9\x19\x00\x00\x25\x1a\x00\x00\x81\x1a\x00\x00\xdd\x1a\x00\x00\x39\x1b\x00\x00\x95\x1b\x00\x00\xf1\x1b\x00\x00\x4d\x1c\x00\x00\xa9\x1c\x00\x00\x05\x1d\x00\x00\x61\x1d\x00\x00\xbd\x1d\x00\x00\x19\x1e\x00\x00\x75\x1e\x00\x00\xd1\x1e\x00\x00\x2d\x1f\x00\x00\x89\x1f\x00\x00\xe5\x1f\x00\x00\x41\x20\x00\x00\x9d\x20\x00\x00\xf9\x20\x00\x00\x55\x21\x00\x00\xb1\x21\x00\x00\x0d\x22\x00\x00\x69\x22\x00\x00\xc5\x22\x00\x00\x21\x23\x00\x00\x7d\x23\x00\x00\xd9\x23\x00\x00\x35\x24\x00\x00\x91\x24\x00\x00\xed\x24\x00\x00\x49\x25\x00\x00\xa5\x25\x00\x00\x01\x26\x00\x00\x5d\x26\x00\x00\xb9\x26\x00\x00\x15\x27\x00\x00\x71\x27\x00\x00\xcd\x27\x00\x00\x29\x28\x00\x00\x85\x28\x00\x00\xe1\x28\x00\x00\x3d\x29\x00\x00\x99\x29\x00\x00\xf5\x29\x00\x00\x51\x2a\x00\x00\xad\x2a\x00\x00\x09\x2b\x00\x00\x65\x2b\x00\x00\xc1\x2b\x00\x00\x1d\x2c\x00\x00\x79\x2c\x00\x00\xd5\x2c\x00\x00\x31\x2d\x00\x00\x8d\x2d\x00\x00\xe9\x2d\x00\x00\x45\x2e\x00\x00\xa1\x2e\x00\x00\xfd\x2e\x00\x00\x59\x2f\x00\x00\xb5\x2f\x00\x00\x11\x30\x00\x00\x6d\x30\x00\x00\xc9\x30\x00\x00\x25\x31\x00\x00\x81\x31\x00\x00\xdd\x31\x00\x00\x39\x32\x00\x00\x95\x32\x00\x00\xf1\x32\x00\x00\x4d\x33\x00\x00\xa9\x33\x00\x00\x05\x34\x00\x00\x61\x34\x00\x00\xbd\x34\x00\x00\x19\x35\x00\x00\x75\x35\x00\x00\xd1\x35\x00\x00\x2d\x36\x00\x00\x89\x36\x00\x00\xe5\x36\x00\x00\x41\x37\x00\x00\x9d\x37\x00\x00\xf9\x37\x00\x00\x55\x38\x00\x00\xb1\x38\x00\x00\x0d\x39\x00\x00\x69\x39\x00\x00\xc5\x39\x00\x00\x21\x3a\x00\x00\x7d\x3a\x00\x00\xd9\x3a\x00\x00\x35\x3b\x00\x00\x91\x3b\x00\x00\xed\x3b\x00\x00\x49\x3c\x00\x00\xa5\x3c\x00\x00\x01\x3d\x00\x00\x5d\x3d\x00\x00\xb9\x3d\x00\x00\x15\x3e\x00\x00\x71\x3e\x00\x00\xcd\x3e\x00\x00\x29\x3f\x00\x00\x85\x3f\x00\x00\xe1\x3f\x00\x00\x3d\x40\x00\x00\x99\x40\x00\x00\x00\x00\x00\x00\xa6\xff\xff\xff\xf5\x40\x00\x00\x51\x41\x00\x00\xad\x41\x00\x00\x09\x42\x00\x00\x65\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe8\xff\xff\xff\x63\x00\x00\x00\x00\x00\x00\x00\xc1\x42\x00\x00\x1d\x43\x00\x00\x79\x43\x00\x00\xd5\x43\x00\x00\x31\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x44\x00\x00\xe9\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x45\x45\x00\x00\xa1\x45\x00\x00\xfd\x45\x00\x00\x59\x46\x00\x00\xb5\x46\x00\x00\x11\x47\x00\x00\x6d\x47\x00\x00\xc9\x47\x00\x00\x25\x48\x00\x00\x81\x48\x00\x00\xdd\x48\x00\x00\x39\x49\x00\x00\x95\x49\x00\x00\xf1\x49\x00\x00\x4d\x4a\x00\x00\xa9\x4a\x00\x00\x05\x4b\x00\x00\x61\x4b\x00\x00\xbd\x4b\x00\x00\x19\x4c\x00\x00\x75\x4c\x00\x00\xd1\x4c\x00\x00\x2d\x4d\x00\x00\x89\x4d\x00\x00\xe5\x4d\x00\x00\x41\x4e\x00\x00\x9d\x4e\x00\x00\xf9\x4e\x00\x00\x55\x4f\x00\x00\xb1\x4f\x00\x00\x0d\x50\x00\x00\x69\x50\x00\x00\xc5\x50\x00\x00\x21\x51\x00\x00\x7d\x51\x00\x00"#  alex_table :: AlexAddr-alex_table = AlexA# "\x00\x00\x75\x00\x26\x00\x26\x00\x26\x00\x17\x00\xff\xff\x1a\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x1c\x00\x25\x00\x28\x00\x68\x00\xff\xff\xff\xff\x6a\x00\x0e\x01\x26\x00\x44\x01\x26\x01\x44\x01\x44\x01\x44\x01\x44\x01\x25\x01\x1f\x01\x20\x01\x44\x01\x44\x01\x44\x01\x74\x00\x17\x01\x44\x01\x27\x01\x28\x01\x28\x01\x28\x01\x28\x01\x28\x01\x28\x01\x28\x01\x28\x01\x28\x01\x1a\x01\x19\x01\x44\x01\x1b\x01\x44\x01\x1d\x01\x23\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\xe4\x00\x44\x01\x44\x01\xe0\x00\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x22\x01\x44\x01\x44\x01\x1c\x01\x44\x01\xd9\x00\x44\x01\xba\x00\xb4\x00\x44\x01\x86\x00\x44\x01\x07\x01\x7c\x00\x44\x01\x44\x01\x7a\x00\xb0\x00\x44\x01\xa5\x00\x99\x00\xf6\x00\x90\x00\xfc\x00\x44\x01\x01\x01\x44\x01\x81\x00\x44\x01\x44\x01\x44\x01\x29\x00\x1e\x01\x24\x01\x44\x01\x76\x00\x26\x00\x26\x00\x26\x00\x1b\x00\x0b\x00\x0b\x00\x0b\x00\xff\xff\x09\x00\x09\x00\x09\x00\xff\xff\x09\x00\x09\x00\x09\x00\xff\xff\xff\xff\x0b\x00\x0b\x00\x0b\x00\xff\xff\x26\x00\x26\x00\x26\x00\x26\x00\x0b\x00\x18\x01\x15\x01\x16\x01\x09\x00\x00\x00\x00\x00\x00\x00\x09\x00\x73\x00\x00\x00\x00\x00\x00\x00\x0b\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x26\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x1d\x00\x2b\x00\x00\x00\xff\xff\x0a\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x75\x00\x26\x00\x26\x00\x26\x00\x00\x00\x00\x00\xff\xff\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x00\x0d\x00\x69\x00\x26\x00\x44\x01\x26\x01\x44\x01\x44\x01\x44\x01\x44\x01\x25\x01\x1f\x01\x20\x01\x44\x01\x44\x01\x44\x01\x74\x00\x17\x01\x44\x01\x27\x01\x28\x01\x28\x01\x28\x01\x28\x01\x28\x01\x28\x01\x28\x01\x28\x01\x28\x01\x1a\x01\x19\x01\x44\x01\x1b\x01\x44\x01\x1d\x01\x23\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\xe4\x00\x44\x01\x44\x01\xe0\x00\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x22\x01\x44\x01\x44\x01\x1c\x01\x44\x01\xd9\x00\x44\x01\xba\x00\xb4\x00\x44\x01\x86\x00\x44\x01\x07\x01\x7c\x00\x44\x01\x44\x01\x7a\x00\xb0\x00\x44\x01\xa5\x00\x99\x00\xf6\x00\x90\x00\xfc\x00\x44\x01\x01\x01\x44\x01\x81\x00\x44\x01\x44\x01\x44\x01\x29\x00\x1e\x01\x24\x01\x44\x01\x26\x00\x26\x00\x26\x00\x75\x00\x26\x00\x26\x00\x26\x00\x77\x00\x26\x00\x26\x00\x26\x00\xff\xff\xff\xff\xff\xff\x27\x00\x27\x00\x27\x00\x27\x00\xff\xff\xff\xff\xff\xff\x26\x00\xff\xff\xff\xff\xff\xff\x26\x00\xff\xff\x00\x00\x00\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x27\x00\x00\x00\x73\x00\x2f\x00\x00\x00\x00\x00\x73\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x39\x00\x40\x00\xff\xff\x61\x00\x00\x00\x00\x00\x00\x00\x55\x00\xff\xff\x00\x00\x64\x00\x00\x00\x00\x00\x32\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x1d\x00\x00\x00\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\x0e\x00\x00\x00\x00\x00\x0f\x00\x00\x00\x0f\x01\x00\x00\x12\x00\x69\x00\x14\x00\xff\xff\x15\x00\x69\x00\x00\x00\x10\x00\xff\xff\x69\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x00\x00\x00\x00\x34\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\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\x35\x00\x00\x00\x00\x00\x00\x00\x2e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x36\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\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\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x37\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x31\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\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\xff\xff\x00\x00\x00\x00\x3c\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\xff\xff\x43\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x45\x00\x00\x00\x00\x00\x00\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x51\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x4a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x4d\x00\x00\x00\xff\xff\x00\x00\x00\x00\x48\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x3f\x00\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\x4b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x4e\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x00\x00\x00\x00\x00\x00\x52\x00\xff\xff\x00\x00\x53\x00\x00\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x59\x00\x5b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\xff\xff\x54\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\x00\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x5d\x00\x5e\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\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x5f\x00\x5a\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\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x62\x00\x00\x00\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x66\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x63\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x70\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\xff\xff\x6e\x00\x00\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x70\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\xff\xff\x6e\x00\x00\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x70\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\x6e\x00\xff\xff\x6e\x00\x00\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x00\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x00\x00\x00\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x70\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x00\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x00\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\xff\xff\x6f\x00\x00\x00\x6f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x00\x00\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x00\x00\x00\x00\x00\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x00\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x00\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x00\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x71\x00\x6d\x00\x6d\x00\x72\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\xff\xff\x6d\x00\x00\x00\x6d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x00\x00\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x00\x00\x00\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x00\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x00\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x00\x00\x6d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x6d\x00\x6f\x00\x6d\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x00\x00\x00\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x00\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x00\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x00\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x6f\x00\x00\x00\x6f\x00\x45\x01\x6f\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x6b\x00\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x21\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x78\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x79\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xca\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xaa\x00\x7b\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x7d\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x7e\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x7f\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x80\x00\x89\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x82\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x83\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x84\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x85\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xe9\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x87\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x88\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x8a\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x8b\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x8c\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x8d\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xbe\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x0d\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x8e\x00\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x8f\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x91\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x92\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x93\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x94\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x95\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x96\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x97\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x98\x00\x45\x01\x45\x01\xa1\x00\x45\x01\x45\x01\x14\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x9a\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x9b\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x9c\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x9d\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x9e\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x9f\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xdd\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xa0\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xa2\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xa3\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xa4\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xa6\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xa7\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xa8\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xa9\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xab\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xac\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xad\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xae\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xaf\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xd1\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xb1\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xb2\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xb3\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xb5\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xb6\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xb7\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xb8\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xc7\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xb9\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xbb\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xbc\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xbd\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xbf\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xc0\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xc1\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xc2\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xc3\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xc4\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xc5\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xc6\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xcb\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xcc\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xc8\x00\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xc9\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xcd\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xce\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xcf\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xd0\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xd2\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xd3\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xd4\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xd5\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xd6\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xd7\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xd8\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xda\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xdb\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xdc\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\xea\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xde\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xdf\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xe1\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xe2\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xe3\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xe5\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xe6\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xe7\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xe8\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xed\x00\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xeb\x00\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\xec\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xee\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xef\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xf0\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xf1\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xf2\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xf3\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xf4\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xf5\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xf7\x00\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xf8\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xf9\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xfa\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xfb\x00\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xfd\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xfe\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\xff\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x02\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x03\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x04\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x05\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x06\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x08\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x09\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x0a\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x0b\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x0c\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x10\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x11\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x12\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x13\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x46\x01\x45\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x00\x00\x00\x00\x46\x01\x46\x01\x46\x01\x46\x01\x00\x00\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x00\x00\x46\x01\x46\x01\x46\x01\x46\x01\x00\x00\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x00\x00\x46\x01\x45\x01\x46\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x44\x01\x45\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x00\x00\x00\x00\x44\x01\x44\x01\x44\x01\x44\x01\x00\x00\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x00\x00\x44\x01\x44\x01\x44\x01\x44\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\x44\x01\x44\x01\x44\x01\x44\x01\x00\x00\x44\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\x44\x01\x45\x01\x44\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x3c\x01\x45\x01\x29\x01\x29\x01\x29\x01\x29\x01\x29\x01\x29\x01\x29\x01\x29\x01\x29\x01\x29\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x41\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x41\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x2e\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x3c\x01\x45\x01\x29\x01\x29\x01\x29\x01\x29\x01\x29\x01\x29\x01\x29\x01\x29\x01\x29\x01\x29\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x41\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x41\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x3c\x01\x45\x01\x29\x01\x29\x01\x29\x01\x29\x01\x29\x01\x29\x01\x29\x01\x29\x01\x29\x01\x29\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x41\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x41\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x3c\x01\x45\x01\x2b\x01\x2b\x01\x2b\x01\x2b\x01\x2b\x01\x2b\x01\x2b\x01\x2b\x01\x2b\x01\x2b\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x2d\x01\x2d\x01\x2d\x01\x2d\x01\x2c\x01\x2d\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x2d\x01\x2d\x01\x2d\x01\x2d\x01\x2c\x01\x2d\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x43\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x3c\x01\x45\x01\x2b\x01\x2b\x01\x2b\x01\x2b\x01\x2b\x01\x2b\x01\x2b\x01\x2b\x01\x2b\x01\x2b\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x2d\x01\x2d\x01\x2d\x01\x2d\x01\x2c\x01\x2d\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x2d\x01\x2d\x01\x2d\x01\x2d\x01\x2c\x01\x2d\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x42\x01\x45\x01\x42\x01\x3c\x01\x45\x01\x2a\x01\x2b\x01\x2b\x01\x2b\x01\x2b\x01\x2b\x01\x2b\x01\x2b\x01\x2b\x01\x2b\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x2d\x01\x2d\x01\x2d\x01\x2d\x01\x2c\x01\x2d\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x2d\x01\x2d\x01\x2d\x01\x2d\x01\x2c\x01\x2d\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x3c\x01\x45\x01\x2d\x01\x2d\x01\x2d\x01\x2d\x01\x2d\x01\x2d\x01\x2d\x01\x2d\x01\x2d\x01\x2d\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x2d\x01\x2d\x01\x2d\x01\x2d\x01\x2c\x01\x2d\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x2d\x01\x2d\x01\x2d\x01\x2d\x01\x2c\x01\x2d\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x2d\x01\x2d\x01\x2d\x01\x2d\x01\x2d\x01\x2d\x01\x2d\x01\x2d\x01\x2d\x01\x2d\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x2d\x01\x2d\x01\x2d\x01\x2d\x01\x2d\x01\x2d\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x2d\x01\x2d\x01\x2d\x01\x2d\x01\x2d\x01\x2d\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x31\x01\x31\x01\x31\x01\x31\x01\x31\x01\x31\x01\x31\x01\x31\x01\x31\x01\x31\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x3e\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x3e\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x3d\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x31\x01\x31\x01\x31\x01\x31\x01\x31\x01\x31\x01\x31\x01\x31\x01\x31\x01\x31\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x3e\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x3e\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x31\x01\x31\x01\x31\x01\x31\x01\x31\x01\x31\x01\x31\x01\x31\x01\x31\x01\x31\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x3e\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x3e\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x3f\x01\x45\x01\x3f\x01\x47\x01\x45\x01\x33\x01\x34\x01\x34\x01\x34\x01\x34\x01\x34\x01\x34\x01\x34\x01\x34\x01\x34\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x35\x01\x35\x01\x35\x01\x35\x01\x32\x01\x35\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x35\x01\x35\x01\x35\x01\x35\x01\x32\x01\x35\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x34\x01\x34\x01\x34\x01\x34\x01\x34\x01\x34\x01\x34\x01\x34\x01\x34\x01\x34\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x35\x01\x35\x01\x35\x01\x35\x01\x32\x01\x35\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x35\x01\x35\x01\x35\x01\x35\x01\x32\x01\x35\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x40\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x34\x01\x34\x01\x34\x01\x34\x01\x34\x01\x34\x01\x34\x01\x34\x01\x34\x01\x34\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x35\x01\x35\x01\x35\x01\x35\x01\x32\x01\x35\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x35\x01\x35\x01\x35\x01\x35\x01\x32\x01\x35\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x35\x01\x35\x01\x35\x01\x35\x01\x35\x01\x35\x01\x35\x01\x35\x01\x35\x01\x35\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x35\x01\x35\x01\x35\x01\x35\x01\x32\x01\x35\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x35\x01\x35\x01\x35\x01\x35\x01\x32\x01\x35\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x37\x01\x37\x01\x37\x01\x37\x01\x37\x01\x37\x01\x37\x01\x37\x01\x37\x01\x37\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x40\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x37\x01\x37\x01\x37\x01\x37\x01\x37\x01\x37\x01\x37\x01\x37\x01\x37\x01\x37\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x38\x01\x38\x01\x38\x01\x38\x01\x38\x01\x38\x01\x38\x01\x38\x01\x38\x01\x38\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x38\x01\x38\x01\x38\x01\x38\x01\x38\x01\x38\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x38\x01\x38\x01\x38\x01\x38\x01\x38\x01\x38\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x3a\x01\x3a\x01\x3a\x01\x3a\x01\x3a\x01\x3a\x01\x3a\x01\x3a\x01\x3a\x01\x3a\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x43\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x3a\x01\x3a\x01\x3a\x01\x3a\x01\x3a\x01\x3a\x01\x3a\x01\x3a\x01\x3a\x01\x3a\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x3b\x01\x3b\x01\x3b\x01\x3b\x01\x3b\x01\x3b\x01\x3b\x01\x3b\x01\x3b\x01\x3b\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x3b\x01\x3b\x01\x3b\x01\x3b\x01\x3b\x01\x3b\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x3b\x01\x3b\x01\x3b\x01\x3b\x01\x3b\x01\x3b\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x44\x01\x45\x01\x44\x01\x44\x01\x44\x01\x44\x01\x00\x00\x00\x00\x00\x00\x44\x01\x44\x01\x44\x01\x44\x01\x00\x00\x44\x01\x2f\x01\x30\x01\x30\x01\x30\x01\x30\x01\x30\x01\x30\x01\x30\x01\x30\x01\x30\x01\x44\x01\x00\x00\x44\x01\x44\x01\x44\x01\x44\x01\x00\x00\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x48\x01\x44\x01\x44\x01\x49\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x00\x00\x44\x01\x45\x01\x44\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x35\x01\x35\x01\x35\x01\x35\x01\x35\x01\x35\x01\x35\x01\x35\x01\x35\x01\x35\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x35\x01\x35\x01\x35\x01\x35\x01\x35\x01\x35\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x35\x01\x35\x01\x35\x01\x35\x01\x35\x01\x35\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x3f\x01\x45\x01\x3f\x01\x47\x01\x45\x01\x36\x01\x37\x01\x37\x01\x37\x01\x37\x01\x37\x01\x37\x01\x37\x01\x37\x01\x37\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x36\x01\x37\x01\x37\x01\x37\x01\x37\x01\x37\x01\x37\x01\x37\x01\x37\x01\x37\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x38\x01\x38\x01\x38\x01\x38\x01\x38\x01\x38\x01\x38\x01\x38\x01\x38\x01\x38\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x38\x01\x38\x01\x38\x01\x38\x01\x38\x01\x38\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x38\x01\x38\x01\x38\x01\x38\x01\x38\x01\x38\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x42\x01\x45\x01\x42\x01\x47\x01\x45\x01\x39\x01\x3a\x01\x3a\x01\x3a\x01\x3a\x01\x3a\x01\x3a\x01\x3a\x01\x3a\x01\x3a\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x39\x01\x3a\x01\x3a\x01\x3a\x01\x3a\x01\x3a\x01\x3a\x01\x3a\x01\x3a\x01\x3a\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x3b\x01\x3b\x01\x3b\x01\x3b\x01\x3b\x01\x3b\x01\x3b\x01\x3b\x01\x3b\x01\x3b\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x3b\x01\x3b\x01\x3b\x01\x3b\x01\x3b\x01\x3b\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x3b\x01\x3b\x01\x3b\x01\x3b\x01\x3b\x01\x3b\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x47\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x45\x01\x00\x00\x45\x01\x46\x01\x45\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x00\x00\x00\x00\x46\x01\x46\x01\x46\x01\x46\x01\x47\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x00\x00\x46\x01\x46\x01\x46\x01\x46\x01\x00\x00\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x00\x00\x46\x01\x44\x01\x46\x01\x44\x01\x44\x01\x44\x01\x44\x01\x00\x00\x00\x00\x00\x00\x44\x01\x44\x01\x44\x01\x44\x01\x00\x00\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x00\x00\x44\x01\x44\x01\x44\x01\x44\x01\x00\x00\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x48\x01\x44\x01\x44\x01\x49\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x00\x00\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x00\x00\x00\x00\x44\x01\x44\x01\x44\x01\x44\x01\x00\x00\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x00\x00\x44\x01\x44\x01\x44\x01\x44\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\x44\x01\x44\x01\x44\x01\x44\x01\x00\x00\x44\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\x44\x01\x46\x01\x44\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x00\x00\x00\x00\x46\x01\x46\x01\x46\x01\x46\x01\x00\x00\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x00\x00\x46\x01\x46\x01\x46\x01\x46\x01\x00\x00\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x46\x01\x00\x00\x46\x01\x00\x00\x46\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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_table = AlexA# "\x00\x00\x7b\x00\x24\x00\x24\x00\x24\x00\x17\x00\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x1a\x00\x23\x00\x26\x00\x6e\x00\xff\xff\xff\xff\x70\x00\x1e\x01\x28\x01\x24\x00\x57\x01\x39\x01\x57\x01\x57\x01\x57\x01\x57\x01\x38\x01\x2f\x01\x30\x01\x57\x01\x57\x01\x57\x01\x7a\x00\x27\x01\x57\x01\x3a\x01\x3b\x01\x3b\x01\x3b\x01\x3b\x01\x3b\x01\x3b\x01\x3b\x01\x3b\x01\x3b\x01\x2a\x01\x29\x01\x57\x01\x2b\x01\x57\x01\x2d\x01\x33\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\xea\x00\x57\x01\x57\x01\xe6\x00\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x32\x01\x57\x01\x57\x01\x2c\x01\x57\x01\xdf\x00\x57\x01\xc0\x00\xba\x00\x57\x01\x8c\x00\x57\x01\x17\x01\x82\x00\x57\x01\x57\x01\x80\x00\xb6\x00\x57\x01\xab\x00\x9f\x00\xfc\x00\x96\x00\x0d\x01\x57\x01\x07\x01\x57\x01\x87\x00\x57\x01\x57\x01\x57\x01\x27\x00\x2e\x01\x37\x01\x57\x01\x7c\x00\x24\x00\x24\x00\x24\x00\x19\x00\x0b\x00\x0b\x00\x0b\x00\xff\xff\x09\x00\x09\x00\x09\x00\xff\xff\x09\x00\x09\x00\x09\x00\xff\xff\xff\xff\x0b\x00\x0b\x00\x0b\x00\xff\xff\x24\x00\x24\x00\x24\x00\x24\x00\x0b\x00\x26\x01\x00\x00\x00\x00\x09\x00\x00\x00\x00\x00\xff\xff\x09\x00\x79\x00\x00\x00\x00\x00\x00\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x1b\x00\x29\x00\x00\x00\xff\xff\x0a\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x24\x00\x24\x00\x24\x00\x00\x00\x00\x00\xff\xff\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x00\x0d\x00\x6f\x00\x24\x00\x57\x01\x39\x01\x57\x01\x57\x01\x57\x01\x57\x01\x38\x01\x2f\x01\x30\x01\x57\x01\x57\x01\x57\x01\x7a\x00\x27\x01\x57\x01\x3a\x01\x3b\x01\x3b\x01\x3b\x01\x3b\x01\x3b\x01\x3b\x01\x3b\x01\x3b\x01\x3b\x01\x2a\x01\x29\x01\x57\x01\x2b\x01\x57\x01\x2d\x01\x33\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\xea\x00\x57\x01\x57\x01\xe6\x00\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x32\x01\x57\x01\x57\x01\x2c\x01\x57\x01\xdf\x00\x57\x01\xc0\x00\xba\x00\x57\x01\x8c\x00\x57\x01\x17\x01\x82\x00\x57\x01\x57\x01\x80\x00\xb6\x00\x57\x01\xab\x00\x9f\x00\xfc\x00\x96\x00\x0d\x01\x57\x01\x07\x01\x57\x01\x87\x00\x57\x01\x57\x01\x57\x01\x27\x00\x2e\x01\x37\x01\x57\x01\x24\x00\x24\x00\x24\x00\x7b\x00\x24\x00\x24\x00\x24\x00\x7d\x00\x24\x00\x24\x00\x24\x00\xff\xff\xff\xff\xff\xff\x25\x00\x25\x00\x25\x00\x25\x00\xff\xff\xff\xff\xff\xff\x24\x00\xff\xff\xff\xff\xff\xff\x24\x00\xff\xff\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x25\x01\x00\x00\x79\x00\x00\x00\x25\x00\x00\x00\x79\x00\x2d\x00\x00\x00\x00\x00\x79\x00\x00\x00\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x00\x00\x37\x00\x3e\x00\x00\x00\x67\x00\xff\xff\x00\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x6a\x00\xff\xff\x00\x00\x30\x00\x00\x00\x00\x00\xff\xff\x55\x00\x00\x00\x1b\x00\x00\x00\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\x0e\x00\x00\x00\x00\x00\x0f\x00\x00\x00\x1f\x01\x00\x00\x12\x00\x6f\x00\x14\x00\xff\xff\x15\x00\x6f\x00\x00\x00\x10\x00\xff\xff\x6f\x00\x13\x00\x34\x01\x00\x00\x00\x00\x00\x00\x00\x00\x2a\x00\x00\x00\x31\x00\x00\x00\x00\x00\x11\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x32\x00\x00\x00\x00\x00\x08\x00\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\x33\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\xff\xff\x34\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\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x35\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x2f\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\x00\x00\x39\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x38\x00\x3a\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x3c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x36\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x3f\x00\xff\xff\x00\x00\x00\x00\x40\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\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x42\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x43\x00\x00\x00\x44\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\x00\x00\x45\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\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x47\x00\x4f\x00\x00\x00\x48\x00\x00\x00\x00\x00\x53\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x4b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x46\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x3d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x4d\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\x50\x00\x51\x00\xff\xff\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\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\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x57\x00\xff\xff\x52\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x56\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x59\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x5c\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x5f\x00\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x63\x00\x62\x00\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\x64\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x65\x00\x60\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x66\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x00\x00\x74\x00\x6c\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x00\x00\x00\x00\x74\x00\x74\x00\x74\x00\x74\x00\x76\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x00\x00\x74\x00\x74\x00\x74\x00\x74\x00\x00\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\xff\xff\x74\x00\x00\x00\x74\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x74\x00\x00\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x00\x00\x00\x00\x74\x00\x74\x00\x74\x00\x74\x00\x76\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x00\x00\x74\x00\x74\x00\x74\x00\x74\x00\x00\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\xff\xff\x74\x00\x00\x00\x74\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x74\x00\x00\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x00\x00\x00\x00\x74\x00\x74\x00\x74\x00\x74\x00\x76\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x00\x00\x74\x00\x74\x00\x74\x00\x74\x00\x00\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\x74\x00\xff\xff\x74\x00\x00\x00\x74\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x75\x00\x00\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x00\x00\x00\x00\x75\x00\x75\x00\x75\x00\x75\x00\x76\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x00\x00\x75\x00\x75\x00\x75\x00\x75\x00\x00\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\xff\xff\x75\x00\x00\x00\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x73\x00\x73\x00\x73\x00\x73\x00\x00\x00\x00\x00\x00\x00\x73\x00\x73\x00\x73\x00\x73\x00\x00\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x00\x00\x73\x00\x73\x00\x73\x00\x73\x00\x00\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x77\x00\x73\x00\x73\x00\x78\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\xff\xff\x73\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x00\x00\x00\x00\x73\x00\x73\x00\x73\x00\x73\x00\x00\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x73\x00\x00\x00\x73\x00\x73\x00\x73\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x73\x00\x73\x00\x73\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x73\x00\x75\x00\x73\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x00\x00\x00\x00\x75\x00\x75\x00\x75\x00\x75\x00\x00\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x00\x00\x75\x00\x75\x00\x75\x00\x75\x00\x00\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x75\x00\x00\x00\x75\x00\x58\x01\x75\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x71\x00\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x31\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x7e\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x7f\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xd0\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xb0\x00\x81\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x83\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x84\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x85\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x86\x00\x8f\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x88\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x89\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x8a\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x8b\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xef\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x8d\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x8e\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x90\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x91\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x92\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x93\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xc4\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x1d\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x94\x00\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x95\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x97\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x98\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x99\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x9a\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x9b\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x9c\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x9d\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x9e\x00\x58\x01\x58\x01\xa7\x00\x58\x01\x58\x01\x24\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xa0\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xa1\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xa2\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xa3\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xa4\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xa5\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xe3\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xa6\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xa8\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xa9\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xaa\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xac\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xad\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xae\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xaf\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xb1\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xb2\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xb3\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xb4\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xb5\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xd7\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xb7\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xb8\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xb9\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xbb\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xbc\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xbd\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xbe\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xcd\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xbf\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xc1\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xc2\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xc3\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xc5\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xc6\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xc7\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xc8\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xc9\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xca\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xcb\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xcc\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xd1\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xd2\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xce\x00\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xcf\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xd3\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xd4\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xd5\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xd6\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xd8\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xd9\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xda\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xdb\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xdc\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xdd\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xde\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xe0\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xe1\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xe2\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\xf0\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xe4\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xe5\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xe7\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xe8\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xe9\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xeb\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xec\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xed\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xee\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xf3\x00\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\xf1\x00\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\xf2\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xf4\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xf5\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xf6\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xf7\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xf8\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xf9\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xfa\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xfb\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xfd\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xfe\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\xff\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x01\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x02\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x03\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x04\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x05\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x06\x01\x58\x01\x58\x01\x58\x01\x58\x01\x11\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x08\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x09\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x0a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x0b\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x0c\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x0e\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x0f\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x10\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x12\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x13\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x14\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x15\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x16\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x18\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x19\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x1a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x1b\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x1c\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x20\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x21\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x22\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x23\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x59\x01\x58\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x00\x00\x00\x00\x59\x01\x59\x01\x59\x01\x59\x01\x00\x00\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x00\x00\x59\x01\x59\x01\x59\x01\x59\x01\x00\x00\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x00\x00\x59\x01\x58\x01\x59\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x57\x01\x58\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x00\x00\x00\x00\x57\x01\x57\x01\x57\x01\x57\x01\x00\x00\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x00\x00\x57\x01\x57\x01\x57\x01\x57\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\x57\x01\x57\x01\x57\x01\x57\x01\x00\x00\x57\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\x57\x01\x58\x01\x57\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x4f\x01\x58\x01\x3c\x01\x3c\x01\x3c\x01\x3c\x01\x3c\x01\x3c\x01\x3c\x01\x3c\x01\x3c\x01\x3c\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x54\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x54\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x41\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x4f\x01\x58\x01\x3c\x01\x3c\x01\x3c\x01\x3c\x01\x3c\x01\x3c\x01\x3c\x01\x3c\x01\x3c\x01\x3c\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x54\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x54\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x4f\x01\x58\x01\x3c\x01\x3c\x01\x3c\x01\x3c\x01\x3c\x01\x3c\x01\x3c\x01\x3c\x01\x3c\x01\x3c\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x54\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x54\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x4f\x01\x58\x01\x3e\x01\x3e\x01\x3e\x01\x3e\x01\x3e\x01\x3e\x01\x3e\x01\x3e\x01\x3e\x01\x3e\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x40\x01\x40\x01\x40\x01\x40\x01\x3f\x01\x40\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x40\x01\x40\x01\x40\x01\x40\x01\x3f\x01\x40\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x56\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x4f\x01\x58\x01\x3e\x01\x3e\x01\x3e\x01\x3e\x01\x3e\x01\x3e\x01\x3e\x01\x3e\x01\x3e\x01\x3e\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x40\x01\x40\x01\x40\x01\x40\x01\x3f\x01\x40\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x40\x01\x40\x01\x40\x01\x40\x01\x3f\x01\x40\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x55\x01\x58\x01\x55\x01\x4f\x01\x58\x01\x3d\x01\x3e\x01\x3e\x01\x3e\x01\x3e\x01\x3e\x01\x3e\x01\x3e\x01\x3e\x01\x3e\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x40\x01\x40\x01\x40\x01\x40\x01\x3f\x01\x40\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x40\x01\x40\x01\x40\x01\x40\x01\x3f\x01\x40\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x4f\x01\x58\x01\x40\x01\x40\x01\x40\x01\x40\x01\x40\x01\x40\x01\x40\x01\x40\x01\x40\x01\x40\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x40\x01\x40\x01\x40\x01\x40\x01\x3f\x01\x40\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x40\x01\x40\x01\x40\x01\x40\x01\x3f\x01\x40\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x40\x01\x40\x01\x40\x01\x40\x01\x40\x01\x40\x01\x40\x01\x40\x01\x40\x01\x40\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x40\x01\x40\x01\x40\x01\x40\x01\x40\x01\x40\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x40\x01\x40\x01\x40\x01\x40\x01\x40\x01\x40\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x51\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x51\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x50\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x51\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x51\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x51\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x51\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x52\x01\x58\x01\x52\x01\x5a\x01\x58\x01\x46\x01\x47\x01\x47\x01\x47\x01\x47\x01\x47\x01\x47\x01\x47\x01\x47\x01\x47\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x48\x01\x48\x01\x48\x01\x48\x01\x45\x01\x48\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x48\x01\x48\x01\x48\x01\x48\x01\x45\x01\x48\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x47\x01\x47\x01\x47\x01\x47\x01\x47\x01\x47\x01\x47\x01\x47\x01\x47\x01\x47\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x48\x01\x48\x01\x48\x01\x48\x01\x45\x01\x48\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x48\x01\x48\x01\x48\x01\x48\x01\x45\x01\x48\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x53\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x47\x01\x47\x01\x47\x01\x47\x01\x47\x01\x47\x01\x47\x01\x47\x01\x47\x01\x47\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x48\x01\x48\x01\x48\x01\x48\x01\x45\x01\x48\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x48\x01\x48\x01\x48\x01\x48\x01\x45\x01\x48\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x48\x01\x48\x01\x48\x01\x48\x01\x48\x01\x48\x01\x48\x01\x48\x01\x48\x01\x48\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x48\x01\x48\x01\x48\x01\x48\x01\x45\x01\x48\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x48\x01\x48\x01\x48\x01\x48\x01\x45\x01\x48\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x4a\x01\x4a\x01\x4a\x01\x4a\x01\x4a\x01\x4a\x01\x4a\x01\x4a\x01\x4a\x01\x4a\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x53\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x4a\x01\x4a\x01\x4a\x01\x4a\x01\x4a\x01\x4a\x01\x4a\x01\x4a\x01\x4a\x01\x4a\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x4b\x01\x4b\x01\x4b\x01\x4b\x01\x4b\x01\x4b\x01\x4b\x01\x4b\x01\x4b\x01\x4b\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x4b\x01\x4b\x01\x4b\x01\x4b\x01\x4b\x01\x4b\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x4b\x01\x4b\x01\x4b\x01\x4b\x01\x4b\x01\x4b\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x4d\x01\x4d\x01\x4d\x01\x4d\x01\x4d\x01\x4d\x01\x4d\x01\x4d\x01\x4d\x01\x4d\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x56\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x4d\x01\x4d\x01\x4d\x01\x4d\x01\x4d\x01\x4d\x01\x4d\x01\x4d\x01\x4d\x01\x4d\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x57\x01\x58\x01\x57\x01\x57\x01\x57\x01\x57\x01\x00\x00\x00\x00\x00\x00\x57\x01\x57\x01\x57\x01\x57\x01\x00\x00\x57\x01\x42\x01\x43\x01\x43\x01\x43\x01\x43\x01\x43\x01\x43\x01\x43\x01\x43\x01\x43\x01\x57\x01\x00\x00\x57\x01\x57\x01\x57\x01\x57\x01\x00\x00\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x5b\x01\x57\x01\x57\x01\x5c\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x00\x00\x57\x01\x58\x01\x57\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x48\x01\x48\x01\x48\x01\x48\x01\x48\x01\x48\x01\x48\x01\x48\x01\x48\x01\x48\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x48\x01\x48\x01\x48\x01\x48\x01\x48\x01\x48\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x48\x01\x48\x01\x48\x01\x48\x01\x48\x01\x48\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x52\x01\x58\x01\x52\x01\x5a\x01\x58\x01\x49\x01\x4a\x01\x4a\x01\x4a\x01\x4a\x01\x4a\x01\x4a\x01\x4a\x01\x4a\x01\x4a\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x49\x01\x4a\x01\x4a\x01\x4a\x01\x4a\x01\x4a\x01\x4a\x01\x4a\x01\x4a\x01\x4a\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x4b\x01\x4b\x01\x4b\x01\x4b\x01\x4b\x01\x4b\x01\x4b\x01\x4b\x01\x4b\x01\x4b\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x4b\x01\x4b\x01\x4b\x01\x4b\x01\x4b\x01\x4b\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x4b\x01\x4b\x01\x4b\x01\x4b\x01\x4b\x01\x4b\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x55\x01\x58\x01\x55\x01\x5a\x01\x58\x01\x4c\x01\x4d\x01\x4d\x01\x4d\x01\x4d\x01\x4d\x01\x4d\x01\x4d\x01\x4d\x01\x4d\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x4c\x01\x4d\x01\x4d\x01\x4d\x01\x4d\x01\x4d\x01\x4d\x01\x4d\x01\x4d\x01\x4d\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x5a\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x58\x01\x00\x00\x58\x01\x59\x01\x58\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x00\x00\x00\x00\x59\x01\x59\x01\x59\x01\x59\x01\x5a\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x00\x00\x59\x01\x59\x01\x59\x01\x59\x01\x00\x00\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x00\x00\x59\x01\x57\x01\x59\x01\x57\x01\x57\x01\x57\x01\x57\x01\x00\x00\x00\x00\x00\x00\x57\x01\x57\x01\x57\x01\x57\x01\x00\x00\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x00\x00\x57\x01\x57\x01\x57\x01\x57\x01\x00\x00\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x5b\x01\x57\x01\x57\x01\x5c\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x00\x00\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x00\x00\x00\x00\x57\x01\x57\x01\x57\x01\x57\x01\x00\x00\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x57\x01\x00\x00\x57\x01\x57\x01\x57\x01\x57\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\x57\x01\x57\x01\x57\x01\x57\x01\x00\x00\x57\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\x57\x01\x59\x01\x57\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x00\x00\x00\x00\x59\x01\x59\x01\x59\x01\x59\x01\x00\x00\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x00\x00\x59\x01\x59\x01\x59\x01\x59\x01\x00\x00\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x59\x01\x00\x00\x59\x01\x00\x00\x59\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0a\x00\x0a\x00\x0a\x00\x65\x00\x6e\x00\x64\x00\x7b\x00\x63\x00\x6f\x00\x64\x00\x7d\x00\x65\x00\x23\x00\x2d\x00\x0a\x00\x0a\x00\x2d\x00\x6f\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\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0a\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0a\x00\x20\x00\x0b\x00\x0c\x00\x0d\x00\x20\x00\x2e\x00\x21\x00\x2e\x00\x20\x00\xff\xff\xff\xff\xff\xff\x20\x00\x2d\x00\xff\xff\xff\xff\xff\xff\x20\x00\x2d\x00\xff\xff\xff\xff\xff\xff\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x20\x00\xff\xff\x5c\x00\x23\x00\xff\xff\x20\x00\x5c\x00\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x20\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x65\x00\x7b\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\x0b\x00\x0c\x00\x0d\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0a\x00\x0a\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0a\x00\x0a\x00\x0a\x00\x20\x00\x0a\x00\x0a\x00\x0a\x00\x20\x00\x0a\x00\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\x20\x00\xff\xff\x2d\x00\x23\x00\xff\xff\xff\xff\x2d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x20\x00\xff\xff\xff\xff\xff\xff\x42\x00\x43\x00\x20\x00\x45\x00\xff\xff\xff\xff\xff\xff\x49\x00\x20\x00\xff\xff\x4c\x00\xff\xff\xff\xff\x4f\x00\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\xff\xff\x69\x00\xff\xff\x74\x00\xff\xff\x63\x00\x7b\x00\x64\x00\x20\x00\x65\x00\x7b\x00\xff\xff\x6e\x00\x20\x00\x7b\x00\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\xff\xff\x7d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\xff\xff\x7d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x20\x00\x4f\x00\xff\xff\xff\xff\xff\xff\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\x4e\x00\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\x53\x00\xff\xff\xff\xff\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x55\x00\x20\x00\xff\xff\xff\xff\x4c\x00\xff\xff\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x49\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x4f\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x20\x00\xff\xff\xff\xff\xff\xff\x4d\x00\xff\xff\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x20\x00\x50\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x20\x00\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x44\x00\x45\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x41\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\x54\x00\xff\xff\x20\x00\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x41\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x54\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x20\x00\xff\xff\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x50\x00\x59\x00\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x20\x00\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\x50\x00\x20\x00\xff\xff\x49\x00\xff\xff\x43\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x20\x00\xff\xff\x4f\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x52\x00\x53\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\x20\x00\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\x20\x00\x54\x00\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\x20\x00\x53\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x49\x00\x42\x00\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\x4c\x00\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\x20\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x45\x00\xff\xff\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\xff\xff\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\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\x0a\x00\x7c\x00\xff\xff\x7e\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\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\x0a\x00\x7c\x00\xff\xff\x7e\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\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\x0a\x00\x7c\x00\xff\xff\x7e\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\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\x0a\x00\x7c\x00\xff\xff\x7e\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\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\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\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\x0a\x00\x7c\x00\xff\xff\x7e\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\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\x5b\x00\x5c\x00\x5d\x00\x5e\x00\xff\xff\x60\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\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\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\x5b\x00\x5c\x00\x5d\x00\x5e\x00\xff\xff\x60\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\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\x5b\x00\x5c\x00\x5d\x00\x5e\x00\xff\xff\x60\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\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\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\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\xff\xff\x7c\x00\xff\xff\x7e\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"#+alex_check = AlexA# "\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0a\x00\x0a\x00\x65\x00\x6e\x00\x64\x00\x7b\x00\x63\x00\x6f\x00\x64\x00\x7d\x00\x65\x00\x23\x00\x2d\x00\x0a\x00\x0a\x00\x2d\x00\x6f\x00\x2e\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\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0a\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0a\x00\x20\x00\x0b\x00\x0c\x00\x0d\x00\x20\x00\x2e\x00\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x0a\x00\x20\x00\x2d\x00\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x21\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x20\x00\xff\xff\x5c\x00\x23\x00\xff\xff\x20\x00\x5c\x00\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x20\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x65\x00\x7b\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\x0b\x00\x0c\x00\x0d\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0a\x00\x0a\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0a\x00\x0a\x00\x0a\x00\x20\x00\x0a\x00\x0a\x00\x0a\x00\x20\x00\x0a\x00\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x21\x00\xff\xff\x2d\x00\xff\xff\x20\x00\xff\xff\x2d\x00\x23\x00\xff\xff\xff\xff\x2d\x00\xff\xff\x2d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x20\x00\xff\xff\x42\x00\x43\x00\xff\xff\x45\x00\x20\x00\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\x4c\x00\x20\x00\xff\xff\x4f\x00\xff\xff\xff\xff\x20\x00\x53\x00\xff\xff\x5c\x00\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\xff\xff\x69\x00\xff\xff\x74\x00\xff\xff\x63\x00\x7b\x00\x64\x00\x20\x00\x65\x00\x7b\x00\xff\xff\x6e\x00\x20\x00\x7b\x00\x6f\x00\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\xff\xff\x50\x00\xff\xff\xff\xff\x7b\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x54\x00\xff\xff\xff\xff\x7d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\x49\x00\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x7d\x00\xff\xff\xff\xff\xff\xff\x20\x00\x4f\x00\xff\xff\xff\xff\xff\xff\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x4e\x00\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\x53\x00\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\x49\x00\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x55\x00\x4c\x00\xff\xff\xff\xff\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x20\x00\xff\xff\xff\xff\xff\xff\x54\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x49\x00\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x4e\x00\xff\xff\xff\xff\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x4f\x00\x20\x00\xff\xff\xff\xff\x4d\x00\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\x50\x00\xff\xff\xff\xff\x49\x00\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x4c\x00\xff\xff\x45\x00\xff\xff\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\x44\x00\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x44\x00\x45\x00\xff\xff\x41\x00\xff\xff\xff\xff\x4a\x00\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\x54\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x5f\x00\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\x41\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x54\x00\x20\x00\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x59\x00\xff\xff\xff\xff\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\x50\x00\xff\xff\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x50\x00\x49\x00\x20\x00\x43\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\x41\x00\x20\x00\x53\x00\xff\xff\xff\xff\xff\xff\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x54\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x43\x00\x49\x00\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\x4d\x00\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\x52\x00\x53\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\x54\x00\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\x49\x00\x53\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x4c\x00\x45\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x20\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\xff\xff\xff\xff\x21\x00\x4e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\x0a\x00\x7c\x00\xff\xff\x7e\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\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\x0a\x00\x7c\x00\xff\xff\x7e\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\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\x0a\x00\x7c\x00\xff\xff\x7e\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\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\x0a\x00\x7c\x00\xff\xff\x7e\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\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\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\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\x0a\x00\x7c\x00\xff\xff\x7e\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\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\x5b\x00\x5c\x00\x5d\x00\x5e\x00\xff\xff\x60\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\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\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\x5b\x00\x5c\x00\x5d\x00\x5e\x00\xff\xff\x60\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\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\x5b\x00\x5c\x00\x5d\x00\x5e\x00\xff\xff\x60\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\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\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\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\xff\xff\x7c\x00\xff\xff\x7e\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"#  alex_deflt :: AlexAddr-alex_deflt = AlexA# "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\xff\xff\xff\xff\x18\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\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\x67\x00\xff\xff\xff\xff\x6c\x00\x6c\x00\x6c\x00\x6c\x00\x6c\x00\x6c\x00\x6c\x00\x6c\x00\x6c\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"#+alex_deflt = AlexA# "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6d\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\xff\xff\xff\xff\x18\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\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\x6d\x00\xff\xff\xff\xff\x72\x00\x72\x00\x72\x00\x72\x00\x72\x00\x72\x00\x72\x00\x72\x00\x72\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\x36\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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,329) [[],[(AlexAccPred  (alex_action_26) ( not' eof ))],[],[(AlexAcc (alex_action_29))],[],[(AlexAcc (alex_action_28))],[],[(AlexAccPred  (alex_action_1) (alexRightContext 25))],[(AlexAccPred  (alex_action_0) (alexRightContext 22)),(AlexAccPred  (alex_action_1) (alexRightContext 25)),(AlexAcc (alex_action_2))],[(AlexAccPred  (alex_action_0) (alexRightContext 22)),(AlexAccPred  (alex_action_1) (alexRightContext 25)),(AlexAcc (alex_action_2))],[(AlexAccPred  (alex_action_1) (alexRightContext 25)),(AlexAcc (alex_action_2))],[(AlexAccPred  (alex_action_1) (alexRightContext 25)),(AlexAcc (alex_action_2))],[(AlexAccPred  (alex_action_1) (alexRightContext 25)),(AlexAcc (alex_action_2))],[(AlexAccPred  (alex_action_1) (alexRightContext 25)),(AlexAcc (alex_action_2))],[(AlexAccPred  (alex_action_1) (alexRightContext 25)),(AlexAcc (alex_action_2))],[(AlexAccPred  (alex_action_1) (alexRightContext 25)),(AlexAcc (alex_action_2))],[(AlexAccPred  (alex_action_1) (alexRightContext 25)),(AlexAcc (alex_action_2))],[(AlexAccPred  (alex_action_1) (alexRightContext 25)),(AlexAcc (alex_action_2))],[(AlexAccPred  (alex_action_1) (alexRightContext 25)),(AlexAcc (alex_action_2))],[(AlexAccPred  (alex_action_1) (alexRightContext 25)),(AlexAcc (alex_action_2))],[(AlexAccPred  (alex_action_1) (alexRightContext 25)),(AlexAcc (alex_action_2))],[(AlexAccPred  (alex_action_1) (alexRightContext 25)),(AlexAcc (alex_action_2))],[],[(AlexAccSkip)],[(AlexAccPred  (alex_action_1) (alexRightContext 25)),(AlexAcc (alex_action_2))],[],[(AlexAccSkip)],[(AlexAccSkip)],[(AlexAccPred  (alex_action_4) ( inState code ))],[],[],[],[],[],[],[],[],[],[(AlexAccSkip)],[(AlexAccSkip)],[(AlexAcc (alex_action_7))],[(AlexAcc (alex_action_77))],[(AlexAccPred  (alex_action_21) ( not' (followedBy '#') ))],[(AlexAcc (alex_action_8))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_9))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_10))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_11))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_12))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_14))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_13))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_15))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_17))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_18))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_19))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_20))],[(AlexAccPred  (alex_action_21) ( not' (followedBy '#') ))],[],[(AlexAccPred  (alex_action_22) ( keepComments .&&. (followedBy '\n' .||. eof) )),(AlexAccSkipPred  ( followedBy '\n' .||. eof ))],[(AlexAccPred  (alex_action_22) ( keepComments .&&. (followedBy '\n' .||. eof) )),(AlexAccSkipPred  ( followedBy '\n' .||. eof )),(AlexAcc (alex_action_83))],[(AlexAccPred  (alex_action_22) ( keepComments .&&. (followedBy '\n' .||. eof) )),(AlexAccSkipPred  ( followedBy '\n' .||. eof ))],[(AlexAccPred  (alex_action_22) ( keepComments .&&. (followedBy '\n' .||. eof) )),(AlexAccSkipPred  ( followedBy '\n' .||. eof )),(AlexAcc (alex_action_83))],[(AlexAccPred  (alex_action_22) ( keepComments .&&. (followedBy '\n' .||. eof) )),(AlexAccSkipPred  ( followedBy '\n' .||. eof )),(AlexAcc (alex_action_83))],[(AlexAccPred  (alex_action_22) ( keepComments .&&. (followedBy '\n' .||. eof) )),(AlexAccSkipPred  ( followedBy '\n' .||. eof )),(AlexAcc (alex_action_83))],[(AlexAccPred  (alex_action_22) ( keepComments .&&. (followedBy '\n' .||. eof) )),(AlexAccSkipPred  ( followedBy '\n' .||. eof ))],[(AlexAccPred  (alex_action_22) ( keepComments .&&. (followedBy '\n' .||. eof) )),(AlexAccSkipPred  ( followedBy '\n' .||. eof ))],[(AlexAccPred  (alex_action_22) ( keepComments .&&. (followedBy '\n' .||. eof) )),(AlexAccSkipPred  ( followedBy '\n' .||. eof ))],[],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_24))],[(AlexAccSkip)],[(AlexAccSkip)],[(AlexAcc (alex_action_30))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_31))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_32))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_33))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_34))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_35))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_36))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_37))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_38))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_39))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_40))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_41))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_42))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_43))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_44))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_45))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_46))],[(AlexAcc (alex_action_47))],[(AlexAcc (alex_action_48))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_49))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_50))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_51))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_52))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_53))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_54))],[(AlexAcc (alex_action_54))],[(AlexAcc (alex_action_54))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_55))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_56))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_57))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_58))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_59))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_60))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_61))],[],[(AlexAcc (alex_action_62))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_63))],[(AlexAcc (alex_action_64))],[(AlexAcc (alex_action_65))],[],[(AlexAcc (alex_action_66))],[(AlexAcc (alex_action_67))],[(AlexAcc (alex_action_68))],[(AlexAcc (alex_action_69))],[(AlexAcc (alex_action_70))],[(AlexAcc (alex_action_71))],[(AlexAcc (alex_action_72))],[(AlexAcc (alex_action_73))],[(AlexAcc (alex_action_74))],[(AlexAcc (alex_action_75))],[(AlexAcc (alex_action_76))],[(AlexAcc (alex_action_78))],[(AlexAcc (alex_action_79))],[(AlexAcc (alex_action_80))],[(AlexAcc (alex_action_81))],[(AlexAcc (alex_action_81))],[(AlexAcc (alex_action_81))],[(AlexAcc (alex_action_81))],[(AlexAcc (alex_action_81))],[(AlexAcc (alex_action_81))],[(AlexAcc (alex_action_81))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_82))],[(AlexAcc (alex_action_82))],[(AlexAcc (alex_action_82))],[(AlexAcc (alex_action_82))],[(AlexAcc (alex_action_82))],[(AlexAcc (alex_action_82))],[(AlexAcc (alex_action_82))],[(AlexAcc (alex_action_82))],[(AlexAcc (alex_action_82))],[(AlexAcc (alex_action_82))],[(AlexAcc (alex_action_82))],[(AlexAcc (alex_action_82))],[(AlexAcc (alex_action_82))],[],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[(AlexAcc (alex_action_83))],[],[],[]]-{-# LINE 193 "src/full/Agda/Syntax/Parser/Lexer.x" #-}+alex_accept = listArray (0::Int,348) [[],[(AlexAccPred  (alex_action_29) ( not' eof ))],[],[(AlexAcc (alex_action_32))],[],[(AlexAcc (alex_action_31))],[],[(AlexAccPred  (alex_action_4) ( eof ))],[(AlexAccPred  (alex_action_0) (alexRightContext 22)),(AlexAccPred  (alex_action_1) ( keepComments )),(AlexAccSkip)],[(AlexAccPred  (alex_action_0) (alexRightContext 22)),(AlexAccPred  (alex_action_1) ( keepComments )),(AlexAccSkip)],[(AlexAccPred  (alex_action_1) ( keepComments )),(AlexAccSkip)],[(AlexAccPred  (alex_action_1) ( keepComments )),(AlexAccSkip)],[(AlexAccPred  (alex_action_1) ( keepComments )),(AlexAccSkip)],[(AlexAccPred  (alex_action_1) ( keepComments )),(AlexAccSkip)],[(AlexAccPred  (alex_action_1) ( keepComments )),(AlexAccSkip)],[(AlexAccPred  (alex_action_1) ( keepComments )),(AlexAccSkip)],[(AlexAccPred  (alex_action_1) ( keepComments )),(AlexAccSkip)],[(AlexAccPred  (alex_action_1) ( keepComments )),(AlexAccSkip)],[(AlexAccPred  (alex_action_1) ( keepComments )),(AlexAccSkip)],[(AlexAccPred  (alex_action_1) ( keepComments )),(AlexAccSkip)],[(AlexAccPred  (alex_action_1) ( keepComments )),(AlexAccSkip)],[(AlexAccPred  (alex_action_1) ( keepComments )),(AlexAccSkip)],[],[(AlexAccSkip)],[(AlexAccPred  (alex_action_1) ( keepComments )),(AlexAccSkip)],[(AlexAccSkip)],[(AlexAccPred  (alex_action_5) ( inState code ))],[],[],[],[],[],[],[],[],[],[(AlexAccSkip)],[(AlexAccSkip)],[(AlexAcc (alex_action_8))],[(AlexAcc (alex_action_84))],[(AlexAccPred  (alex_action_24) ( not' (followedBy '#') ))],[(AlexAcc (alex_action_9))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_10))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_11))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_12))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_13))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_15))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_14))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_16))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_17))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_18))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_19))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_20))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_21))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_22))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAcc (alex_action_23))],[(AlexAccPred  (alex_action_24) ( not' (followedBy '#') ))],[],[(AlexAccPred  (alex_action_25) ( keepComments .&&. (followedBy '\n' .||. eof) )),(AlexAccSkipPred  ( followedBy '\n' .||. eof ))],[(AlexAccPred  (alex_action_25) ( keepComments .&&. (followedBy '\n' .||. eof) )),(AlexAccSkipPred  ( followedBy '\n' .||. eof )),(AlexAcc (alex_action_90))],[(AlexAccPred  (alex_action_25) ( keepComments .&&. (followedBy '\n' .||. eof) )),(AlexAccSkipPred  ( followedBy '\n' .||. eof ))],[(AlexAccPred  (alex_action_25) ( keepComments .&&. (followedBy '\n' .||. eof) )),(AlexAccSkipPred  ( followedBy '\n' .||. eof )),(AlexAcc (alex_action_90))],[(AlexAccPred  (alex_action_25) ( keepComments .&&. (followedBy '\n' .||. eof) )),(AlexAccSkipPred  ( followedBy '\n' .||. eof )),(AlexAcc (alex_action_90))],[(AlexAccPred  (alex_action_25) ( keepComments .&&. (followedBy '\n' .||. eof) )),(AlexAccSkipPred  ( followedBy '\n' .||. eof )),(AlexAcc (alex_action_90))],[(AlexAccPred  (alex_action_25) ( keepComments .&&. (followedBy '\n' .||. eof) )),(AlexAccSkipPred  ( followedBy '\n' .||. eof ))],[(AlexAccPred  (alex_action_25) ( keepComments .&&. (followedBy '\n' .||. eof) )),(AlexAccSkipPred  ( followedBy '\n' .||. eof ))],[(AlexAccPred  (alex_action_25) ( keepComments .&&. (followedBy '\n' .||. eof) )),(AlexAccSkipPred  ( followedBy '\n' .||. eof ))],[],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_27))],[(AlexAccSkip)],[(AlexAccSkip)],[(AlexAcc (alex_action_33))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_34))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_35))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_36))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_37))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_38))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_39))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_40))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_41))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_42))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_43))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_44))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_45))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_46))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_47))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_48))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_49))],[(AlexAcc (alex_action_50))],[(AlexAcc (alex_action_51))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_52))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_53))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_54))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_55))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_56))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_57))],[(AlexAcc (alex_action_57))],[(AlexAcc (alex_action_57))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_58))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_59))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_60))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_61))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_62))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_63))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_64))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_65))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_66))],[],[(AlexAcc (alex_action_67))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_68))],[(AlexAcc (alex_action_69))],[(AlexAcc (alex_action_71))],[(AlexAcc (alex_action_70))],[(AlexAcc (alex_action_72))],[(AlexAcc (alex_action_73))],[(AlexAcc (alex_action_74))],[(AlexAcc (alex_action_75))],[(AlexAcc (alex_action_76))],[(AlexAcc (alex_action_77))],[(AlexAcc (alex_action_78))],[(AlexAcc (alex_action_79))],[(AlexAcc (alex_action_80))],[(AlexAcc (alex_action_81))],[(AlexAcc (alex_action_82))],[(AlexAccPred  (alex_action_83) (alexRightContext 309))],[],[(AlexAccSkip)],[(AlexAcc (alex_action_85))],[(AlexAcc (alex_action_86))],[(AlexAcc (alex_action_87))],[(AlexAcc (alex_action_88))],[(AlexAcc (alex_action_88))],[(AlexAcc (alex_action_88))],[(AlexAcc (alex_action_88))],[(AlexAcc (alex_action_88))],[(AlexAcc (alex_action_88))],[(AlexAcc (alex_action_88))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_89))],[(AlexAcc (alex_action_89))],[(AlexAcc (alex_action_89))],[(AlexAcc (alex_action_89))],[(AlexAcc (alex_action_89))],[(AlexAcc (alex_action_89))],[(AlexAcc (alex_action_89))],[(AlexAcc (alex_action_89))],[(AlexAcc (alex_action_89))],[(AlexAcc (alex_action_89))],[(AlexAcc (alex_action_89))],[(AlexAcc (alex_action_89))],[(AlexAcc (alex_action_89))],[],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[(AlexAcc (alex_action_90))],[],[],[]]+{-# LINE 208 "src/full/Agda/Syntax/Parser/Lexer.x" #-}   -- | This is the initial state for parsing a literate file. Code blocks@@ -147,82 +148,88 @@ tex = 7 alex_action_0 =  end_  alex_action_1 =  withInterval TokTeX -alex_action_2 =  withInterval TokTeX -alex_action_4 =  begin_ tex -alex_action_7 =  begin pragma -alex_action_8 =  symbol SymOpenPragma -alex_action_9 =  endWith $ symbol SymClosePragma -alex_action_10 =  keyword KwOPTIONS -alex_action_11 =  keyword KwBUILTIN -alex_action_12 =  keyword KwCOMPILED_DATA -alex_action_13 =  keyword KwCOMPILED_TYPE -alex_action_14 =  keyword KwCOMPILED -alex_action_15 =  keyword KwCOMPILED_EPIC -alex_action_16 =  keyword KwIMPORT -alex_action_17 =  keyword KwIMPOSSIBLE -alex_action_18 =  keyword KwETA -alex_action_19 =  keyword KwLINE -alex_action_20 =  withInterval $ TokString -alex_action_21 =  nestedComment -alex_action_22 =  withInterval TokComment -alex_action_24 =  begin bol_ -alex_action_26 =  offsideRule -alex_action_28 =  endWith newLayoutContext -alex_action_29 =  emptyLayout -alex_action_30 =  keyword KwLet -alex_action_31 =  keyword KwIn -alex_action_32 =  keyword KwWhere -alex_action_33 =  keyword KwField -alex_action_34 =  keyword KwWith -alex_action_35 =  keyword KwRewrite -alex_action_36 =  keyword KwPostulate -alex_action_37 =  keyword KwPrimitive -alex_action_38 =  keyword KwOpen -alex_action_39 =  keyword KwImport -alex_action_40 =  keyword KwModule -alex_action_41 =  keyword KwData -alex_action_42 =  keyword KwCoData -alex_action_43 =  keyword KwRecord -alex_action_44 =  keyword KwConstructor -alex_action_45 =  keyword KwInfix -alex_action_46 =  keyword KwInfixL -alex_action_47 =  keyword KwInfixR -alex_action_48 =  keyword KwMutual -alex_action_49 =  keyword KwAbstract -alex_action_50 =  keyword KwPrivate -alex_action_51 =  keyword KwSet -alex_action_52 =  keyword KwProp -alex_action_53 =  keyword KwForall -alex_action_54 =  withInterval' (read . drop 3) TokSetN -alex_action_55 =  keyword KwQuoteGoal -alex_action_56 =  keyword KwQuote -alex_action_57 =  keyword KwSyntax -alex_action_58 =  keyword KwUsing -alex_action_59 =  keyword KwHiding -alex_action_60 =  keyword KwRenaming -alex_action_61 =  endWith $ keyword KwTo -alex_action_62 =  keyword KwPublic -alex_action_63 =  hole -alex_action_64 =  symbol SymEllipsis -alex_action_65 =  symbol SymDot -alex_action_66 =  symbol SymSemi -alex_action_67 =  symbol SymColon -alex_action_68 =  symbol SymEqual -alex_action_69 =  symbol SymUnderscore -alex_action_70 =  symbol SymQuestionMark -alex_action_71 =  symbol SymBar -alex_action_72 =  symbol SymOpenParen -alex_action_73 =  symbol SymCloseParen -alex_action_74 =  symbol SymArrow -alex_action_75 =  symbol SymLambda -alex_action_76 =  symbol SymAs -alex_action_77 =  symbol SymOpenBrace -alex_action_78 =  symbol SymCloseBrace -alex_action_79 =  litChar -alex_action_80 =  litString -alex_action_81 =  literal LitInt -alex_action_82 =  literal LitFloat -alex_action_83 =  identifier +alex_action_4 =  end_ +alex_action_5 =  begin_ tex +alex_action_8 =  begin pragma +alex_action_9 =  symbol SymOpenPragma +alex_action_10 =  endWith $ symbol SymClosePragma +alex_action_11 =  keyword KwOPTIONS +alex_action_12 =  keyword KwBUILTIN +alex_action_13 =  keyword KwCOMPILED_DATA +alex_action_14 =  keyword KwCOMPILED_TYPE +alex_action_15 =  keyword KwCOMPILED +alex_action_16 =  keyword KwCOMPILED_EPIC +alex_action_17 =  keyword KwCOMPILED_JS +alex_action_18 =  keyword KwSTATIC +alex_action_19 =  keyword KwIMPORT +alex_action_20 =  keyword KwIMPOSSIBLE +alex_action_21 =  keyword KwETA +alex_action_22 =  keyword KwLINE +alex_action_23 =  withInterval $ TokString +alex_action_24 =  nestedComment +alex_action_25 =  withInterval TokComment +alex_action_27 =  begin bol_ +alex_action_29 =  offsideRule +alex_action_31 =  endWith newLayoutContext +alex_action_32 =  emptyLayout +alex_action_33 =  keyword KwLet +alex_action_34 =  keyword KwIn +alex_action_35 =  keyword KwWhere +alex_action_36 =  keyword KwField +alex_action_37 =  keyword KwWith +alex_action_38 =  keyword KwRewrite +alex_action_39 =  keyword KwPostulate +alex_action_40 =  keyword KwPrimitive +alex_action_41 =  keyword KwOpen +alex_action_42 =  keyword KwImport +alex_action_43 =  keyword KwModule +alex_action_44 =  keyword KwData +alex_action_45 =  keyword KwCoData +alex_action_46 =  keyword KwRecord +alex_action_47 =  keyword KwConstructor +alex_action_48 =  keyword KwInfix +alex_action_49 =  keyword KwInfixL +alex_action_50 =  keyword KwInfixR +alex_action_51 =  keyword KwMutual +alex_action_52 =  keyword KwAbstract +alex_action_53 =  keyword KwPrivate +alex_action_54 =  keyword KwSet +alex_action_55 =  keyword KwProp +alex_action_56 =  keyword KwForall +alex_action_57 =  withInterval' (read . drop 3) TokSetN +alex_action_58 =  keyword KwQuoteGoal +alex_action_59 =  keyword KwQuote +alex_action_60 =  keyword KwQuoteTerm +alex_action_61 =  keyword KwUnquote +alex_action_62 =  keyword KwSyntax +alex_action_63 =  keyword KwUsing +alex_action_64 =  keyword KwHiding +alex_action_65 =  keyword KwRenaming +alex_action_66 =  endWith $ keyword KwTo +alex_action_67 =  keyword KwPublic +alex_action_68 =  hole +alex_action_69 =  symbol SymEllipsis +alex_action_70 =  symbol SymDotDot +alex_action_71 =  symbol SymDot +alex_action_72 =  symbol SymSemi +alex_action_73 =  symbol SymColon +alex_action_74 =  symbol SymEqual +alex_action_75 =  symbol SymUnderscore +alex_action_76 =  symbol SymQuestionMark +alex_action_77 =  symbol SymBar +alex_action_78 =  symbol SymOpenParen +alex_action_79 =  symbol SymCloseParen +alex_action_80 =  symbol SymArrow +alex_action_81 =  symbol SymLambda +alex_action_82 =  symbol SymAs +alex_action_83 =  symbol SymDoubleOpenBrace +alex_action_84 =  symbol SymOpenBrace +alex_action_85 =  symbol SymCloseBrace +alex_action_86 =  litChar +alex_action_87 =  litString +alex_action_88 =  literal LitInt +alex_action_89 =  literal LitFloat +alex_action_90 =  identifier  {-# LINE 1 "templates/GenericTemplate.hs" #-} {-# LINE 1 "templates/GenericTemplate.hs" #-} {-# LINE 1 "<built-in>" #-}@@ -253,10 +260,10 @@ #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#+        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@@ -353,12 +360,12 @@   	let-		!(base) = alexIndexInt32OffAddr alex_base s-		!((I# (ord_c))) = ord c-		!(offset) = (base +# ord_c)-		!(check)  = alexIndexInt16OffAddr alex_check offset+		(base) = alexIndexInt32OffAddr alex_base s+		((I# (ord_c))) = ord c+		(offset) = (base +# ord_c)+		(check)  = alexIndexInt16OffAddr alex_check offset 		-		!(new_s) = if (offset >=# 0#) && (check ==# ord_c)+		(new_s) = if (offset >=# 0#) && (check ==# ord_c) 			  then alexIndexInt16OffAddr alex_table offset 			  else alexIndexInt16OffAddr alex_deflt s 	in

dist/build/Agda/Syntax/Parser/Parser.hs view

@@ -1,4200 +1,4996 @@-{-# OPTIONS_GHC -fno-warn-overlapping-patterns #-}-{-# OPTIONS -fglasgow-exts -cpp #-}-{-# OPTIONS_GHC -fno-warn-incomplete-patterns-                -fno-warn-deprecated-flags #-}-{-| The parser is generated by Happy (<http://www.haskell.org/happy>).--}-module Agda.Syntax.Parser.Parser (-      moduleParser-    , exprParser-    , tokensParser-    , tests-    ) where--import Control.Arrow-import Control.Monad-import Control.Monad.State-import Data.Char-import Data.List-import Data.Maybe-import qualified Data.Traversable as T--import Agda.Syntax.Position hiding (tests)-import Agda.Syntax.Parser.Monad-import Agda.Syntax.Parser.Lexer-import Agda.Syntax.Parser.Tokens-import Agda.Syntax.Concrete-import Agda.Syntax.Concrete.Name-import Agda.Syntax.Concrete.Pretty-import Agda.Syntax.Common-import Agda.Syntax.Fixity-import Agda.Syntax.Notation-import Agda.Syntax.Literal--import Agda.Utils.Monad-import Agda.Utils.QuickCheck-import Agda.Utils.TestHelpers-import qualified Data.Array as Happy_Data_Array-import qualified GHC.Exts as Happy_GHC_Exts---- parser produced by Happy Version 1.18.5--newtype HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63 = HappyAbsSyn HappyAny-#if __GLASGOW_HASKELL__ >= 607-type HappyAny = Happy_GHC_Exts.Any-#else-type HappyAny = forall a . a-#endif-happyIn6 :: ([Token]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn6 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn6 #-}-happyOut6 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([Token])-happyOut6 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut6 #-}-happyIn7 :: ([Token]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn7 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn7 #-}-happyOut7 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([Token])-happyOut7 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut7 #-}-happyIn8 :: (Token) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn8 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn8 #-}-happyOut8 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (Token)-happyOut8 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut8 #-}-happyIn9 :: (()) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn9 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn9 #-}-happyOut9 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (())-happyOut9 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut9 #-}-happyIn10 :: (([Pragma], [Declaration])) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn10 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn10 #-}-happyOut10 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (([Pragma], [Declaration]))-happyOut10 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut10 #-}-happyIn11 :: t11 -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn11 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn11 #-}-happyOut11 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> t11-happyOut11 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut11 #-}-happyIn12 :: t12 -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn12 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn12 #-}-happyOut12 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> t12-happyOut12 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut12 #-}-happyIn13 :: t13 -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn13 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn13 #-}-happyOut13 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> t13-happyOut13 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut13 #-}-happyIn14 :: (()) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn14 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn14 #-}-happyOut14 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (())-happyOut14 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut14 #-}-happyIn15 :: (Integer) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn15 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn15 #-}-happyOut15 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (Integer)-happyOut15 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut15 #-}-happyIn16 :: (Name) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn16 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn16 #-}-happyOut16 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (Name)-happyOut16 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut16 #-}-happyIn17 :: ([Name]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn17 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn17 #-}-happyOut17 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([Name])-happyOut17 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut17 #-}-happyIn18 :: (Arg Name) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn18 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn18 #-}-happyOut18 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (Arg Name)-happyOut18 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut18 #-}-happyIn19 :: ([Arg Name]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn19 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn19 #-}-happyOut19 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([Arg Name])-happyOut19 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut19 #-}-happyIn20 :: ([Arg Name]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn20 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn20 #-}-happyOut20 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([Arg Name])-happyOut20 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut20 #-}-happyIn21 :: (QName) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn21 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn21 #-}-happyOut21 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (QName)-happyOut21 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut21 #-}-happyIn22 :: (QName) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn22 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn22 #-}-happyOut22 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (QName)-happyOut22 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut22 #-}-happyIn23 :: (Name) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn23 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn23 #-}-happyOut23 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (Name)-happyOut23 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut23 #-}-happyIn24 :: ([Name]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn24 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn24 #-}-happyOut24 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([Name])-happyOut24 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut24 #-}-happyIn25 :: ([Name]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn25 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn25 #-}-happyOut25 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([Name])-happyOut25 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut25 #-}-happyIn26 :: ([String]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn26 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn26 #-}-happyOut26 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([String])-happyOut26 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut26 #-}-happyIn27 :: (QName) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn27 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn27 #-}-happyOut27 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (QName)-happyOut27 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut27 #-}-happyIn28 :: (Expr) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn28 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn28 #-}-happyOut28 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (Expr)-happyOut28 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut28 #-}-happyIn29 :: t29 -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn29 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn29 #-}-happyOut29 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> t29-happyOut29 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut29 #-}-happyIn30 :: ([Expr]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn30 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn30 #-}-happyOut30 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([Expr])-happyOut30 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut30 #-}-happyIn31 :: ([Expr]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn31 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn31 #-}-happyOut31 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([Expr])-happyOut31 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut31 #-}-happyIn32 :: t32 -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn32 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn32 #-}-happyOut32 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> t32-happyOut32 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut32 #-}-happyIn33 :: ([Expr]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn33 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn33 #-}-happyOut33 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([Expr])-happyOut33 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut33 #-}-happyIn34 :: t34 -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn34 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn34 #-}-happyOut34 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> t34-happyOut34 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut34 #-}-happyIn35 :: ([(Name, Expr)]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn35 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn35 #-}-happyOut35 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([(Name, Expr)])-happyOut35 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut35 #-}-happyIn36 :: ([(Name, Expr)]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn36 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn36 #-}-happyOut36 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([(Name, Expr)])-happyOut36 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut36 #-}-happyIn37 :: ((Name, Expr)) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn37 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn37 #-}-happyOut37 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ((Name, Expr))-happyOut37 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut37 #-}-happyIn38 :: t38 -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn38 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn38 #-}-happyOut38 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> t38-happyOut38 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut38 #-}-happyIn39 :: t39 -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn39 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn39 #-}-happyOut39 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> t39-happyOut39 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut39 #-}-happyIn40 :: ([TypedBindings]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn40 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn40 #-}-happyOut40 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([TypedBindings])-happyOut40 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut40 #-}-happyIn41 :: (TypedBindings) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn41 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn41 #-}-happyOut41 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (TypedBindings)-happyOut41 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut41 #-}-happyIn42 :: ([TypedBinding]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn42 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn42 #-}-happyOut42 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([TypedBinding])-happyOut42 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut42 #-}-happyIn43 :: ([TypedBinding]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn43 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn43 #-}-happyOut43 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([TypedBinding])-happyOut43 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut43 #-}-happyIn44 :: (TypedBinding) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn44 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn44 #-}-happyOut44 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (TypedBinding)-happyOut44 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut44 #-}-happyIn45 :: ([LamBinding]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn45 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn45 #-}-happyOut45 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([LamBinding])-happyOut45 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut45 #-}-happyIn46 :: (([LamBinding], Hiding)) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn46 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn46 #-}-happyOut46 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (([LamBinding], Hiding))-happyOut46 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut46 #-}-happyIn47 :: ([Either Hiding LamBinding]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn47 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn47 #-}-happyOut47 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([Either Hiding LamBinding])-happyOut47 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut47 #-}-happyIn48 :: ([LamBinding]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn48 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn48 #-}-happyOut48 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([LamBinding])-happyOut48 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut48 #-}-happyIn49 :: ([LamBinding]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn49 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn49 #-}-happyOut49 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([LamBinding])-happyOut49 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut49 #-}-happyIn50 :: ([LamBinding]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn50 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn50 #-}-happyOut50 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([LamBinding])-happyOut50 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut50 #-}-happyIn51 :: ([LamBinding]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn51 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn51 #-}-happyOut51 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([LamBinding])-happyOut51 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut51 #-}-happyIn52 :: ((Maybe AsName, ImportDirective)) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn52 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn52 #-}-happyOut52 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ((Maybe AsName, ImportDirective))-happyOut52 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut52 #-}-happyIn53 :: (ImportDirective) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn53 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn53 #-}-happyOut53 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (ImportDirective)-happyOut53 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut53 #-}-happyIn54 :: (ImportDirective) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn54 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn54 #-}-happyOut54 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (ImportDirective)-happyOut54 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut54 #-}-happyIn55 :: (ImportDirective) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn55 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn55 #-}-happyOut55 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (ImportDirective)-happyOut55 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut55 #-}-happyIn56 :: ((UsingOrHiding , Range)) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn56 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn56 #-}-happyOut56 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ((UsingOrHiding , Range))-happyOut56 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut56 #-}-happyIn57 :: (([Renaming] , Range)) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn57 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn57 #-}-happyOut57 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (([Renaming] , Range))-happyOut57 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut57 #-}-happyIn58 :: ([Renaming]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn58 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn58 #-}-happyOut58 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([Renaming])-happyOut58 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut58 #-}-happyIn59 :: (Renaming) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn59 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn59 #-}-happyOut59 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (Renaming)-happyOut59 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut59 #-}-happyIn60 :: (ImportedName) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn60 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn60 #-}-happyOut60 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (ImportedName)-happyOut60 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut60 #-}-happyIn61 :: (ImportedName) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn61 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn61 #-}-happyOut61 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (ImportedName)-happyOut61 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut61 #-}-happyIn62 :: ([ImportedName]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn62 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn62 #-}-happyOut62 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([ImportedName])-happyOut62 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut62 #-}-happyIn63 :: t63 -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn63 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn63 #-}-happyOut63 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> t63-happyOut63 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut63 #-}-happyIn64 :: (LHS) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn64 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn64 #-}-happyOut64 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (LHS)-happyOut64 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut64 #-}-happyIn65 :: ([Pattern]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn65 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn65 #-}-happyOut65 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([Pattern])-happyOut65 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut65 #-}-happyIn66 :: ([Expr]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn66 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn66 #-}-happyOut66 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([Expr])-happyOut66 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut66 #-}-happyIn67 :: ([Expr]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn67 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn67 #-}-happyOut67 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([Expr])-happyOut67 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut67 #-}-happyIn68 :: (WhereClause) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn68 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn68 #-}-happyOut68 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (WhereClause)-happyOut68 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut68 #-}-happyIn69 :: ([Declaration]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn69 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn69 #-}-happyOut69 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([Declaration])-happyOut69 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut69 #-}-happyIn70 :: ([Declaration]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn70 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn70 #-}-happyOut70 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([Declaration])-happyOut70 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut70 #-}-happyIn71 :: (Declaration) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn71 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn71 #-}-happyOut71 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (Declaration)-happyOut71 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut71 #-}-happyIn72 :: ([Declaration]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn72 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn72 #-}-happyOut72 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([Declaration])-happyOut72 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut72 #-}-happyIn73 :: ([Arg Declaration]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn73 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn73 #-}-happyOut73 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([Arg Declaration])-happyOut73 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut73 #-}-happyIn74 :: (Declaration) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn74 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn74 #-}-happyOut74 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (Declaration)-happyOut74 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut74 #-}-happyIn75 :: (RHS) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn75 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn75 #-}-happyOut75 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (RHS)-happyOut75 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut75 #-}-happyIn76 :: (Declaration) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn76 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn76 #-}-happyOut76 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (Declaration)-happyOut76 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut76 #-}-happyIn77 :: (Declaration) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn77 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn77 #-}-happyOut77 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (Declaration)-happyOut77 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut77 #-}-happyIn78 :: (Name) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn78 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn78 #-}-happyOut78 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (Name)-happyOut78 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut78 #-}-happyIn79 :: (Declaration) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn79 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn79 #-}-happyOut79 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (Declaration)-happyOut79 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut79 #-}-happyIn80 :: ([Declaration]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn80 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn80 #-}-happyOut80 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([Declaration])-happyOut80 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut80 #-}-happyIn81 :: (Declaration) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn81 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn81 #-}-happyOut81 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (Declaration)-happyOut81 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut81 #-}-happyIn82 :: (Declaration) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn82 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn82 #-}-happyOut82 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (Declaration)-happyOut82 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut82 #-}-happyIn83 :: (Declaration) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn83 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn83 #-}-happyOut83 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (Declaration)-happyOut83 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut83 #-}-happyIn84 :: (Declaration) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn84 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn84 #-}-happyOut84 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (Declaration)-happyOut84 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut84 #-}-happyIn85 :: (Declaration) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn85 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn85 #-}-happyOut85 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (Declaration)-happyOut85 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut85 #-}-happyIn86 :: (Declaration) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn86 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn86 #-}-happyOut86 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (Declaration)-happyOut86 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut86 #-}-happyIn87 :: ([String]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn87 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn87 #-}-happyOut87 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([String])-happyOut87 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut87 #-}-happyIn88 :: ([HoleName]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn88 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn88 #-}-happyOut88 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([HoleName])-happyOut88 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut88 #-}-happyIn89 :: (HoleName) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn89 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn89 #-}-happyOut89 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (HoleName)-happyOut89 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut89 #-}-happyIn90 :: (String) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn90 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn90 #-}-happyOut90 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (String)-happyOut90 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut90 #-}-happyIn91 :: (Declaration) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn91 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn91 #-}-happyOut91 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (Declaration)-happyOut91 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut91 #-}-happyIn92 :: ([Expr]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn92 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn92 #-}-happyOut92 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([Expr])-happyOut92 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut92 #-}-happyIn93 :: (Declaration) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn93 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn93 #-}-happyOut93 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (Declaration)-happyOut93 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut93 #-}-happyIn94 :: (Declaration) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn94 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn94 #-}-happyOut94 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (Declaration)-happyOut94 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut94 #-}-happyIn95 :: (Declaration) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn95 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn95 #-}-happyOut95 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (Declaration)-happyOut95 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut95 #-}-happyIn96 :: ([Declaration]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn96 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn96 #-}-happyOut96 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([Declaration])-happyOut96 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut96 #-}-happyIn97 :: (Declaration) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn97 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn97 #-}-happyOut97 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (Declaration)-happyOut97 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut97 #-}-happyIn98 :: (Declaration) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn98 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn98 #-}-happyOut98 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (Declaration)-happyOut98 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut98 #-}-happyIn99 :: (Pragma) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn99 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn99 #-}-happyOut99 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (Pragma)-happyOut99 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut99 #-}-happyIn100 :: (Pragma) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn100 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn100 #-}-happyOut100 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (Pragma)-happyOut100 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut100 #-}-happyIn101 :: (Pragma) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn101 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn101 #-}-happyOut101 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (Pragma)-happyOut101 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut101 #-}-happyIn102 :: (Pragma) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn102 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn102 #-}-happyOut102 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (Pragma)-happyOut102 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut102 #-}-happyIn103 :: (Pragma) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn103 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn103 #-}-happyOut103 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (Pragma)-happyOut103 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut103 #-}-happyIn104 :: (Pragma) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn104 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn104 #-}-happyOut104 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (Pragma)-happyOut104 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut104 #-}-happyIn105 :: (Pragma) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn105 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn105 #-}-happyOut105 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (Pragma)-happyOut105 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut105 #-}-happyIn106 :: (Pragma) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn106 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn106 #-}-happyOut106 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (Pragma)-happyOut106 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut106 #-}-happyIn107 :: (Pragma) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn107 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn107 #-}-happyOut107 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (Pragma)-happyOut107 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut107 #-}-happyIn108 :: (Pragma) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn108 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn108 #-}-happyOut108 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (Pragma)-happyOut108 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut108 #-}-happyIn109 :: (Pragma) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn109 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn109 #-}-happyOut109 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (Pragma)-happyOut109 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut109 #-}-happyIn110 :: ([TypeSignature]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn110 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn110 #-}-happyOut110 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([TypeSignature])-happyOut110 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut110 #-}-happyIn111 :: ([TypeSignature]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn111 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn111 #-}-happyOut111 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([TypeSignature])-happyOut111 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut111 #-}-happyIn112 :: ([TypeSignature]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn112 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn112 #-}-happyOut112 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([TypeSignature])-happyOut112 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut112 #-}-happyIn113 :: ([TypeSignature]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn113 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn113 #-}-happyOut113 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([TypeSignature])-happyOut113 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut113 #-}-happyIn114 :: ([Arg TypeSignature]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn114 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn114 #-}-happyOut114 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([Arg TypeSignature])-happyOut114 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut114 #-}-happyIn115 :: ([Arg TypeSignature]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn115 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn115 #-}-happyOut115 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([Arg TypeSignature])-happyOut115 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut115 #-}-happyIn116 :: ([Constructor]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn116 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn116 #-}-happyOut116 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([Constructor])-happyOut116 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut116 #-}-happyIn117 :: ((Maybe Name, [Declaration])) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn117 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn117 #-}-happyOut117 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ((Maybe Name, [Declaration]))-happyOut117 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut117 #-}-happyIn118 :: ([Declaration]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn118 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn118 #-}-happyOut118 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([Declaration])-happyOut118 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut118 #-}-happyIn119 :: ([Declaration]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn119 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn119 #-}-happyOut119 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([Declaration])-happyOut119 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut119 #-}-happyIn120 :: ([Declaration]) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyIn120 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyIn120 #-}-happyOut120 :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> ([Declaration])-happyOut120 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut120 #-}-happyInTok :: (Token) -> (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63)-happyInTok x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyInTok #-}-happyOutTok :: (HappyAbsSyn t11 t12 t13 t29 t32 t34 t38 t39 t63) -> (Token)-happyOutTok x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOutTok #-}---happyActOffsets :: HappyAddr-happyActOffsets = HappyA# "\x00\x00\xaf\x03\xe9\x04\x00\x00\x5d\x02\xaf\x00\xd7\x04\xe7\x04\x00\x00\xe7\x04\xdd\x04\x00\x00\xcc\x04\x00\x00\x00\x00\x00\x00\x00\x00\x48\x01\x31\x03\xaf\x03\xdc\x04\x00\x00\x91\x01\xe4\x04\xce\x04\x00\x00\x00\x00\x42\x04\xc6\x04\x00\x00\x00\x00\x08\x01\x00\x00\x00\x00\xc3\x03\x0f\x03\xed\x02\x00\x00\x00\x00\x00\x00\x99\x04\x7b\x01\xcf\x04\xb8\x04\xc2\x04\xaf\x04\xae\x04\x00\x00\x90\x04\x8f\x04\x00\x00\x00\x00\x00\x00\xc3\x03\xaf\x03\x00\x00\x84\x04\xc3\x03\x00\x00\x85\x03\x70\x03\x00\x00\xcb\x02\xa7\x00\xb7\x04\xfb\x02\x5b\x03\x83\x04\xfb\x02\xc4\x03\xc4\x03\x75\x04\x73\x04\xa3\x04\x00\x00\xc4\x03\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x03\xc4\x03\x08\x01\x00\x00\x00\x00\x77\x04\x77\x04\x00\x00\x77\x04\x00\x00\xfa\xff\xf9\x02\xf9\x02\x82\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x04\x00\x00\x00\x00\xfb\x02\x96\x00\x08\x01\xf9\x02\x00\x00\x3c\x01\x00\x00\x00\x00\x00\x00\x00\x00\x61\x04\x00\x00\x00\x00\xc4\x03\x5b\x03\x6c\x04\x6d\x04\x5b\x04\x00\x00\x66\x04\xe8\xff\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x03\x00\x00\x00\x00\x5b\x03\x5b\x03\x58\x04\x00\x00\x62\x04\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x04\x00\x00\x5b\x03\xa1\x02\xf9\xff\x00\x00\x96\x00\x08\x01\xd0\x03\x00\x00\x00\x00\x00\x00\x00\x00\x7e\x04\x00\x00\x53\x04\x50\x04\x4f\x04\x0e\x03\x45\x04\xfb\x02\x7c\x04\xfb\x02\x3e\x04\x35\x04\x00\x00\x00\x00\x00\x00\x52\x04\x00\x00\xd0\x03\x00\x00\x67\x04\x52\x00\x52\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1d\x00\x4e\x04\x00\x00\xc5\x01\x70\x04\x3b\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x04\x40\x04\xc9\x00\x29\x04\x29\x04\x29\x04\x86\x01\x37\x04\x1d\x04\x1d\x04\x1d\x04\x34\x04\x34\x04\x34\x04\x10\x04\x26\x04\x08\x01\x7d\x06\x00\x00\x00\x00\x5b\x03\x00\x00\x00\x00\x1b\x04\x18\x04\x1a\x04\x16\x04\x16\x04\x16\x04\x16\x04\x16\x04\xfd\x00\x4b\x04\x08\x01\x8d\x00\x00\x00\x00\x00\x00\x00\xc3\x00\x00\x00\xc3\x00\xc3\x00\x0b\x04\x00\x00\xfb\x02\xfb\x02\xfb\x02\xfb\x02\x0e\x04\x0a\x04\x00\x00\x08\x04\x00\x00\x4a\x00\x5b\x03\x3f\x04\x5b\x03\x5b\x03\xa1\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x04\x06\x04\x00\x00\x01\x04\x05\x04\xfc\x03\xfb\x03\x04\x04\x25\x04\x00\x00\x00\x00\xee\x03\x00\x00\x00\x00\xfe\x03\xe6\x03\xe6\x03\x17\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x52\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x03\x00\x00\x00\x00\xfa\x03\xe2\x03\xf5\x03\xf5\x03\xfb\x02\x10\x00\xf2\x03\xf1\x03\xe7\x03\xeb\x03\xc3\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x00\x00\xe0\x03\x00\x00\xd6\x03\x08\x01\xff\x03\x5b\x03\xbe\x03\x00\x00\xbe\x03\xbd\x03\xb5\x03\xb4\x03\x00\x00\xab\x03\xac\x03\xaa\x03\x00\x00\x00\x00\xa8\x03\xa0\x03\xa6\x03\xa5\x03\x00\x00\x00\x00\x00\x00\x83\x03\x00\x00\x83\x03\x00\x00\xfe\x00\xf9\xff\x5b\x03\x5b\x03\x5b\x03\x97\x03\x5b\x03\x8f\x03\x7b\x03\xf9\xff\x0f\x00\xf9\xff\xb8\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x02\x00\x00\x8e\x03\x1d\x00\x8e\x03\x00\x00\x0f\x00\x86\x03\x00\x00\x74\x03\x1d\x00\x81\x03\x68\x03\x77\x03\x00\x00\x5b\x03\xd0\x03\x00\x00\xa3\x03\xa1\x03\x98\x03\x1d\x00\x6b\x03\xfe\x00\x64\x03\x00\x00\x2a\x01\x0f\x00\x4e\x03\x00\x00\x5e\x03\x00\x00\x00\x00\x51\x03\x00\x00\x00\x00\x00\x00\x49\x03\x00\x00\x4d\x03\x00\x00\x39\x03\x5b\x03\x00\x00\xfe\x00\x00\x00\x5c\x03\x5c\x03\x5c\x03\x00\x00\xd0\x03\x5b\x03\x00\x00\x2d\x03\x00\x00\x5b\x03\x00\x00\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x34\x03\x00\x00\x00\x00\x00\x00\x30\x03\x00\x00\x00\x00\x00\x00\x2c\x03\xfe\x00\x28\x03\x00\x00\x00\x00\xfe\x00\x3f\x03\x3f\x03\x12\x00\xd4\x01\xf9\xff\x00\x00\x1d\x00\x00\x00\xf9\xff\x1d\x03\x00\x00\x00\x00\x1d\x00\x32\x03\x00\x00\xf9\xff\x00\x00\x1d\x00\x00\x00\x00\x00"#--happyGotoOffsets :: HappyAddr-happyGotoOffsets = HappyA# "\xef\x02\x79\x06\x11\x00\x56\x03\x52\x03\xf5\x01\x00\x00\x4f\x03\x00\x00\x4b\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb9\x03\x64\x06\x00\x00\x00\x00\x8b\x02\x0e\x00\x00\x00\x00\x00\x00\x00\x6d\x01\x3b\x03\x00\x00\x00\x00\x0f\x01\x00\x00\x00\x00\x1f\x00\x4d\x04\x32\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1b\x02\x4f\x06\x00\x00\x00\x00\xe7\x01\x00\x00\x8a\x04\x76\x04\x00\x00\x3a\x06\x25\x06\x00\x00\x13\x03\x10\x06\x00\x00\x2c\x02\x68\x04\x3c\x03\x2c\x00\x00\x00\x00\x00\x00\x00\xf8\x02\x00\x00\x00\x00\x00\x00\x00\x00\xfb\x05\x65\x03\xd4\x00\x00\x00\x00\x00\x30\x00\x08\x00\x00\x00\x2f\x00\x00\x00\xb6\x02\x30\x02\x14\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x03\x00\x00\x00\x00\xce\x02\xa2\x04\x36\x00\xcf\x01\x00\x00\x9f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0\x03\xe6\x05\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd1\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x04\x00\x00\x00\x00\xbc\x05\xa7\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x32\x01\x00\x00\x92\x05\x6c\x01\xa8\x02\x00\x00\x8d\x04\x35\x00\xcb\x04\x00\x00\x00\x00\x00\x00\x00\x00\x01\x03\x00\x00\x00\x00\x00\x00\x00\x00\xc5\x02\x35\x03\x9b\x02\x00\x00\xfa\x01\x00\x00\x15\x03\x00\x00\x00\x00\x00\x00\x07\x00\x00\x00\xb6\x04\x00\x00\xfa\x00\xd6\x00\x27\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2a\x03\x23\x03\x00\x00\x00\x00\xd6\x02\xde\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x06\x00\x37\x01\x04\x03\xfc\x02\xf7\x02\xf2\x02\x16\x00\xe9\x02\xdb\x02\xd8\x02\x0d\x00\x0c\x00\x0b\x00\xcd\x02\x9a\x02\xb1\x00\x00\x00\x00\x00\x00\x00\xf8\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb8\x02\xad\x02\x9f\x02\x91\x02\x47\x02\x00\x00\x18\x02\x6e\x01\x7e\x02\x00\x00\x00\x00\x00\x00\x83\x01\x00\x00\x70\x01\x57\x01\x00\x00\x00\x00\xef\x01\xb5\x01\x82\x01\x6f\x01\x2f\x02\x00\x00\x00\x00\x00\x00\x00\x00\xfd\x01\x7d\x05\xdb\x01\x68\x05\x53\x05\x0e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x02\x00\x00\x03\x02\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\xfb\x01\xec\x01\xeb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xca\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x05\x00\x00\x00\x00\x0a\x00\xe9\x01\x04\x00\x1e\x00\x11\x01\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xdb\x00\x00\x00\x00\x00\x00\x00\x50\x02\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x01\x44\x01\x81\x01\x29\x05\xa0\x01\x00\x00\x90\x01\x00\x00\x85\x01\x00\x00\x00\x00\x00\x00\x79\x01\x00\x00\x00\x00\x00\x00\x00\x00\x4e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x01\x00\x00\x93\x00\x00\x00\x21\x00\x42\x02\x14\x05\xff\x04\xea\x04\x05\x00\xd5\x04\x00\x00\xb2\x00\x35\x02\x84\x00\xfc\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\x00\x00\x09\x00\x50\x01\x40\x01\x00\x00\x6f\x03\x00\x00\x00\x00\x12\x01\x00\x01\xf5\x00\xcc\x01\x00\x00\x00\x00\xc0\x04\x9e\x03\x00\x00\x00\x00\x00\x00\x00\x00\xd5\x00\xd0\x00\xd0\x02\x00\x00\x00\x00\xb7\x00\xb7\x02\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd1\xff\x00\x00\x00\x00\x00\x00\x4c\x00\xab\x04\x00\x00\x20\x00\x00\x00\x03\x00\x18\x00\x17\x00\x00\x00\xba\x02\x91\x04\x00\x00\x15\x00\x00\x00\x87\x01\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x01\x00\x00\x00\x00\x00\x00\x9f\x00\xff\xff\x1b\x00\x1c\x00\x4e\x00\xbb\x01\x00\x00\x66\x00\x00\x00\x88\x01\x44\x00\x00\x00\x00\x00\x3d\x00\xfe\xff\x00\x00\x37\x00\x00\x00\x33\x00\x00\x00\x00\x00"#--happyDefActions :: HappyAddr-happyDefActions = HappyA# "\xfa\xff\x00\x00\xb5\xff\x00\x00\xfc\xff\x00\x00\x00\x00\xb5\xff\xb2\xff\xb5\xff\x9c\xff\x82\xff\x00\x00\x8f\xff\x8e\xff\x8c\xff\x8b\xff\x00\x00\x86\xff\x00\x00\x00\x00\x6c\xff\x6a\xff\xb5\xff\x00\x00\x7e\xff\x7d\xff\x00\x00\x00\x00\x7c\xff\x7b\xff\x00\x00\x7f\xff\x80\xff\x00\x00\x00\x00\x00\x00\xaa\xff\x9d\xff\x81\xff\x00\x00\x9c\xff\x00\x00\x00\x00\x8c\xff\x00\x00\x67\xff\x77\xff\x00\x00\x00\x00\x76\xff\x9a\xff\x51\xff\x5c\xff\x00\x00\x88\xff\x60\xff\x5d\xff\x99\xff\x00\x00\x00\x00\x74\xff\x00\x00\x00\x00\x00\x00\x55\xff\x00\x00\x00\x00\x56\xff\x00\x00\x00\x00\x72\xff\x00\x00\x00\x00\x6b\xff\x00\x00\x6d\xff\x92\xff\x8a\xff\x83\xff\x00\x00\x00\x00\x00\x00\xb4\xff\xb3\xff\xb5\xff\xb5\xff\xf7\xfe\xb5\xff\xf2\xfe\x00\x00\x00\x00\x00\x00\x00\x00\xfb\xff\xf9\xff\xf8\xff\xf7\xff\xf6\xff\xf5\xff\xf4\xff\xf3\xff\xf2\xff\xf1\xff\xf0\xff\xef\xff\xee\xff\xed\xff\xec\xff\xeb\xff\xea\xff\xe9\xff\xe8\xff\xe7\xff\xe6\xff\xe5\xff\xe4\xff\xe3\xff\xe2\xff\xe1\xff\xe0\xff\xdf\xff\xde\xff\xdd\xff\xdc\xff\xdb\xff\xda\xff\xd9\xff\xd4\xff\xd3\xff\xd8\xff\xd7\xff\xd6\xff\xd5\xff\xd2\xff\xd1\xff\xd0\xff\xcf\xff\xce\xff\xcd\xff\xcc\xff\xcb\xff\xca\xff\xc9\xff\xc8\xff\xc7\xff\xc6\xff\xc5\xff\xc4\xff\xc3\xff\xc2\xff\xc1\xff\xc0\xff\xbf\xff\xbe\xff\xbd\xff\xbc\xff\xbb\xff\xba\xff\xb9\xff\xb8\xff\xb7\xff\xb6\xff\x95\xff\x9c\xff\x9b\xff\x52\xff\x47\xff\xfe\xfe\x00\x00\xb1\xff\x00\x00\xf6\xfe\xf5\xfe\x75\xff\x8d\xff\x00\x00\x90\xff\x96\xff\x86\xff\x00\x00\xb5\xff\x00\x00\x00\x00\x71\xff\x70\xff\x00\x00\x58\xff\x59\xff\x91\xff\x57\xff\x00\x00\x5a\xff\x5b\xff\x5f\xff\x61\xff\x89\xff\x5e\xff\x69\xff\x78\xff\x00\x00\x68\xff\x7a\xff\x00\x00\x00\x00\x00\x00\x62\xff\x63\xff\x65\xff\x66\xff\x85\xff\x50\xff\x00\x00\x73\xff\x00\x00\x00\x00\xb5\xff\x87\xff\x47\xff\xfe\xfe\x47\xff\xfa\xfe\x4f\xff\x4d\xff\x4b\xff\x48\xff\x49\xff\x00\x00\x00\x00\x00\x00\x47\xff\x00\x00\x52\xff\x00\x00\x52\xff\x00\x00\x95\xff\x94\xff\xe9\xfe\x54\xff\xb5\xff\x53\xff\x47\xff\x4c\xff\xac\xff\x00\x00\x3c\xff\x4a\xff\xff\xfe\xfd\xfe\xf9\xfe\x00\x00\xb5\xff\xae\xff\x9c\xff\x32\xff\x15\xff\xcd\xfe\x2d\xff\x2b\xff\x2a\xff\x29\xff\x28\xff\x2c\xff\x27\xff\x26\xff\x25\xff\x24\xff\x23\xff\x1d\xff\x22\xff\x20\xff\x21\xff\x1f\xff\x1e\xff\xf3\xfe\xf1\xfe\xf0\xfe\xee\xfe\xef\xfe\xed\xfe\xea\xfe\xec\xfe\xeb\xfe\xb5\xff\xb5\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\xff\x00\x00\x00\x00\x00\x00\xb5\xff\xb5\xff\xb5\xff\x00\x00\x36\xff\x00\x00\x00\x00\x6e\xff\x6f\xff\x00\x00\x79\xff\x64\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\xff\x32\xff\x00\x00\x00\x00\x0a\xff\x0b\xff\x0c\xff\x00\x00\xab\xff\x00\x00\x00\x00\x00\x00\x0d\xff\x52\xff\x52\xff\x52\xff\x52\xff\x00\x00\x00\x00\x08\xff\x00\x00\x09\xff\x30\xff\x00\x00\x34\xff\x00\x00\x00\x00\x00\x00\xd1\xfe\xaf\xff\xb0\xff\xad\xff\x3e\xff\x3a\xff\x00\x00\x3b\xff\x00\x00\x00\x00\x00\x00\x00\x00\x42\xff\x00\x00\xac\xff\x4e\xff\x00\x00\xcf\xfe\xf4\xfe\xb5\xff\x00\x00\x00\x00\xac\xff\x44\xff\x40\xff\x45\xff\x3d\xff\x46\xff\x00\x00\xce\xfe\x1a\xff\x31\xff\x38\xff\x00\x00\x16\xff\x17\xff\xb5\xff\x00\x00\xb5\xff\xb5\xff\x52\xff\x00\x00\x00\x00\x00\x00\x00\x00\xb5\xff\x97\xff\x10\xff\x0f\xff\x0e\xff\x00\x00\x04\xff\x02\xff\x00\x00\x00\xff\x36\xff\x84\xff\x34\xff\x00\x00\x95\xff\x93\xff\x95\xff\x00\x00\x95\xff\x00\x00\xe1\xfe\x00\x00\x00\x00\x00\x00\xe2\xfe\xe3\xfe\x00\x00\x95\xff\x00\x00\x00\x00\x1b\xff\x37\xff\x35\xff\x00\x00\x03\xff\x00\x00\x98\xff\x00\x00\xb5\xff\x00\x00\x00\x00\x00\x00\xb5\xff\x00\x00\x00\x00\x00\x00\xb5\xff\x00\x00\xb5\xff\x00\x00\x2f\xff\x33\xff\x39\xff\x43\xff\x41\xff\x3f\xff\x00\x00\xd0\xfe\xb5\xff\x00\x00\xb5\xff\xa6\xff\xa4\xff\x00\x00\xdb\xfe\x00\x00\x00\x00\xb5\xff\xa8\xff\x00\x00\xde\xfe\x00\x00\x47\xff\xf8\xfe\x00\x00\x00\x00\x00\x00\x00\x00\xb5\xff\xa2\xff\x00\x00\xd8\xfe\x00\x00\x00\x00\x07\xff\x06\xff\x00\x00\xe4\xfe\xe6\xfe\x00\x00\xe7\xfe\xe8\xfe\xe5\xfe\x00\x00\x05\xff\x00\x00\xa7\xff\x00\x00\x00\x00\xa3\xff\x00\x00\xda\xfe\xb5\xff\xb5\xff\xb5\xff\xfc\xfe\x47\xff\x00\x00\xa9\xff\x00\x00\xe0\xfe\x00\x00\xa5\xff\x00\x00\xdd\xfe\x2e\xff\xdc\xfe\x19\xff\xdf\xfe\x1c\xff\xfb\xfe\x00\x00\xd6\xfe\x14\xff\x13\xff\x00\x00\x12\xff\xd9\xfe\x18\xff\x00\x00\xa0\xff\x00\x00\x01\xff\xa1\xff\x9e\xff\xb5\xff\xb5\xff\x00\x00\x00\x00\xb5\xff\x9f\xff\x00\x00\xd5\xfe\xb5\xff\x00\x00\xd7\xfe\x11\xff\x00\x00\xb5\xff\xd2\xfe\xb5\xff\xd4\xfe\x00\x00\xd3\xfe"#--happyCheck :: HappyAddr-happyCheck = HappyA# "\xff\xff\x03\x00\x03\x00\x09\x00\x03\x00\x03\x00\x03\x00\x03\x00\x03\x00\x03\x00\x03\x00\x03\x00\x03\x00\x03\x00\x03\x00\x03\x00\x03\x00\x03\x00\x00\x00\x03\x00\x03\x00\x04\x00\x05\x00\x03\x00\x30\x00\x03\x00\x03\x00\x03\x00\x03\x00\x00\x00\x03\x00\x0a\x00\x0b\x00\x03\x00\x06\x00\x3b\x00\x2b\x00\x54\x00\x0a\x00\x0b\x00\x2f\x00\x0a\x00\x0a\x00\x0a\x00\x0c\x00\x0c\x00\x0e\x00\x0e\x00\x11\x00\x0a\x00\x03\x00\x03\x00\x05\x00\x0a\x00\x0a\x00\x0c\x00\x0d\x00\x06\x00\x03\x00\x41\x00\x42\x00\x2e\x00\x07\x00\x0a\x00\x0a\x00\x31\x00\x23\x00\x06\x00\x0f\x00\x0f\x00\x27\x00\x28\x00\x29\x00\x1d\x00\x1e\x00\x1f\x00\x2d\x00\x03\x00\x0a\x00\x3d\x00\x41\x00\x1c\x00\x1c\x00\x41\x00\x06\x00\x40\x00\x0a\x00\x0b\x00\x0a\x00\x0f\x00\x3d\x00\x3e\x00\x40\x00\x0f\x00\x37\x00\x38\x00\x39\x00\x0f\x00\x5a\x00\x43\x00\x43\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x5a\x00\x06\x00\x42\x00\x68\x00\x6b\x00\x72\x00\x72\x00\x6f\x00\x72\x00\x72\x00\x70\x00\x71\x00\x70\x00\x71\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x70\x00\x68\x00\x68\x00\x6d\x00\x6c\x00\x6a\x00\x69\x00\x6e\x00\x6e\x00\x69\x00\x3a\x00\x5a\x00\x5a\x00\x56\x00\x56\x00\x3f\x00\x0a\x00\x41\x00\x0c\x00\x0d\x00\x44\x00\x41\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x54\x00\x0a\x00\x0b\x00\x0c\x00\x55\x00\x0e\x00\x57\x00\x58\x00\x59\x00\x01\x00\x0a\x00\x5c\x00\x0c\x00\x5e\x00\x0e\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x06\x00\x08\x00\x09\x00\x12\x00\x0a\x00\x0a\x00\x0a\x00\x0b\x00\x0f\x00\x0f\x00\x0f\x00\x0a\x00\x1b\x00\x1c\x00\x1d\x00\x38\x00\x42\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1c\x00\x41\x00\x28\x00\x29\x00\x2a\x00\x09\x00\x03\x00\x0a\x00\x2e\x00\x31\x00\x41\x00\x0f\x00\x32\x00\x33\x00\x06\x00\x35\x00\x38\x00\x0a\x00\x38\x00\x0a\x00\x3a\x00\x3b\x00\x0f\x00\x51\x00\x0a\x00\x41\x00\x54\x00\x41\x00\x42\x00\x3a\x00\x44\x00\x11\x00\x12\x00\x3f\x00\x3f\x00\x1c\x00\x41\x00\x40\x00\x08\x00\x44\x00\x32\x00\x46\x00\x47\x00\x03\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x37\x00\x08\x00\x39\x00\x41\x00\x55\x00\x06\x00\x57\x00\x58\x00\x59\x00\x41\x00\x42\x00\x5c\x00\x37\x00\x5e\x00\x39\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x0a\x00\x0a\x00\x12\x00\x0a\x00\x0a\x00\x0f\x00\x0f\x00\x34\x00\x35\x00\x36\x00\x11\x00\x1b\x00\x1c\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1c\x00\x2e\x00\x30\x00\x34\x00\x35\x00\x36\x00\x29\x00\x2a\x00\x36\x00\x23\x00\x0a\x00\x2e\x00\x0c\x00\x3a\x00\x0e\x00\x32\x00\x33\x00\x0a\x00\x2c\x00\x2d\x00\x41\x00\x38\x00\x0a\x00\x3a\x00\x03\x00\x08\x00\x09\x00\x0f\x00\x10\x00\x3a\x00\x41\x00\x42\x00\x0f\x00\x44\x00\x3f\x00\x0a\x00\x41\x00\x1e\x00\x1f\x00\x44\x00\x0f\x00\x46\x00\x47\x00\x06\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x1b\x00\x1c\x00\x0a\x00\x14\x00\x55\x00\x3a\x00\x57\x00\x58\x00\x59\x00\x11\x00\x12\x00\x5c\x00\x41\x00\x5e\x00\x54\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x0a\x00\x0a\x00\x0a\x00\x0a\x00\x0a\x00\x0f\x00\x34\x00\x0f\x00\x11\x00\x37\x00\x11\x00\x11\x00\x12\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1b\x00\x1c\x00\x03\x00\x0a\x00\x0a\x00\x15\x00\x07\x00\x23\x00\x0a\x00\x23\x00\x11\x00\x11\x00\x12\x00\x0f\x00\x2a\x00\x2b\x00\x14\x00\x2d\x00\x2c\x00\x2d\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x14\x00\x23\x00\x3a\x00\x20\x00\x21\x00\x22\x00\x23\x00\x3f\x00\x31\x00\x41\x00\x2c\x00\x2d\x00\x44\x00\x36\x00\x46\x00\x47\x00\x14\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x3c\x00\x03\x00\x0a\x00\x3a\x00\x55\x00\x07\x00\x57\x00\x58\x00\x59\x00\x11\x00\x41\x00\x5c\x00\x38\x00\x5e\x00\x3a\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x00\x00\x01\x00\x0a\x00\x0b\x00\x23\x00\x0a\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0f\x00\x10\x00\x3b\x00\x2c\x00\x2d\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\x0a\x00\x1e\x00\x0a\x00\x55\x00\x30\x00\x0a\x00\x58\x00\x11\x00\x0a\x00\x5b\x00\x36\x00\x28\x00\x29\x00\x2a\x00\x03\x00\x11\x00\x2d\x00\x2e\x00\x07\x00\x0a\x00\x0a\x00\x32\x00\x33\x00\x08\x00\x35\x00\x23\x00\x11\x00\x38\x00\x0a\x00\x3a\x00\x0a\x00\x29\x00\x3d\x00\x23\x00\x3f\x00\x2d\x00\x41\x00\x42\x00\x3c\x00\x44\x00\x00\x00\x01\x00\x2c\x00\x2d\x00\x23\x00\x0a\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0f\x00\x10\x00\x0a\x00\x2c\x00\x2d\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x11\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x0a\x00\x1e\x00\x03\x00\x0a\x00\x0a\x00\x3e\x00\x07\x00\x11\x00\x23\x00\x0f\x00\x10\x00\x28\x00\x29\x00\x2a\x00\x29\x00\x03\x00\x2d\x00\x2e\x00\x2d\x00\x07\x00\x55\x00\x32\x00\x33\x00\x58\x00\x35\x00\x23\x00\x5b\x00\x38\x00\x5d\x00\x3a\x00\x5f\x00\x3d\x00\x3d\x00\x2b\x00\x3f\x00\x2d\x00\x41\x00\x42\x00\x15\x00\x44\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\x01\x00\x53\x00\x54\x00\x0a\x00\x15\x00\x06\x00\x07\x00\x08\x00\x09\x00\x03\x00\x11\x00\x22\x00\x23\x00\x07\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x15\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x23\x00\x1e\x00\x0a\x00\x0a\x00\x15\x00\x0c\x00\x0d\x00\x0f\x00\x10\x00\x2c\x00\x2d\x00\x28\x00\x29\x00\x2a\x00\x01\x00\x15\x00\x2d\x00\x2e\x00\x52\x00\x53\x00\x54\x00\x32\x00\x33\x00\x3b\x00\x35\x00\x0a\x00\x0a\x00\x38\x00\x0a\x00\x3a\x00\x0c\x00\x12\x00\x0e\x00\x11\x00\x3f\x00\x09\x00\x41\x00\x42\x00\x09\x00\x44\x00\x1b\x00\x1c\x00\x1d\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x01\x00\x00\x00\x01\x00\x23\x00\x09\x00\x28\x00\x29\x00\x2a\x00\x31\x00\x32\x00\x33\x00\x2e\x00\x2c\x00\x2d\x00\x0a\x00\x32\x00\x33\x00\x12\x00\x35\x00\x0a\x00\x0a\x00\x38\x00\x39\x00\x3a\x00\x0a\x00\x0f\x00\x1b\x00\x1c\x00\x1d\x00\x13\x00\x41\x00\x42\x00\x0a\x00\x44\x00\x01\x00\x19\x00\x1a\x00\x3d\x00\x1c\x00\x28\x00\x29\x00\x2a\x00\x0a\x00\x0b\x00\x0c\x00\x2e\x00\x24\x00\x0a\x00\x26\x00\x32\x00\x33\x00\x12\x00\x35\x00\x45\x00\x11\x00\x38\x00\x03\x00\x3a\x00\x3b\x00\x14\x00\x1b\x00\x1c\x00\x1d\x00\x32\x00\x41\x00\x42\x00\x06\x00\x44\x00\x01\x00\x38\x00\x33\x00\x3a\x00\x23\x00\x28\x00\x29\x00\x2a\x00\x41\x00\x42\x00\x41\x00\x2e\x00\x2b\x00\x0a\x00\x2d\x00\x32\x00\x33\x00\x12\x00\x35\x00\x0a\x00\x0a\x00\x38\x00\x39\x00\x3a\x00\x14\x00\x0f\x00\x1b\x00\x1c\x00\x03\x00\x13\x00\x41\x00\x42\x00\x03\x00\x44\x00\x02\x00\x19\x00\x1a\x00\x01\x00\x1c\x00\x28\x00\x29\x00\x2a\x00\x01\x00\x2b\x00\x41\x00\x2e\x00\x24\x00\x39\x00\x26\x00\x32\x00\x33\x00\x34\x00\x35\x00\x3b\x00\x37\x00\x38\x00\x2b\x00\x3a\x00\x3c\x00\x12\x00\x41\x00\x0a\x00\x3c\x00\x01\x00\x41\x00\x42\x00\x0f\x00\x44\x00\x1b\x00\x1c\x00\x1d\x00\x0a\x00\x41\x00\x0c\x00\x0d\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x12\x00\x28\x00\x29\x00\x2a\x00\x01\x00\x2b\x00\x3b\x00\x2e\x00\x41\x00\x1b\x00\x1c\x00\x32\x00\x33\x00\x41\x00\x35\x00\x40\x00\x34\x00\x38\x00\x30\x00\x3a\x00\x2b\x00\x12\x00\x28\x00\x29\x00\x2a\x00\x03\x00\x41\x00\x42\x00\x2e\x00\x44\x00\x1b\x00\x1c\x00\x32\x00\x33\x00\x03\x00\x35\x00\x03\x00\x30\x00\x38\x00\x41\x00\x3a\x00\x3b\x00\x2b\x00\x28\x00\x29\x00\x2a\x00\x01\x00\x41\x00\x42\x00\x2e\x00\x44\x00\x41\x00\x30\x00\x32\x00\x33\x00\x2b\x00\x35\x00\x03\x00\x41\x00\x38\x00\x39\x00\x3a\x00\x31\x00\x12\x00\x2b\x00\x0a\x00\x41\x00\x01\x00\x41\x00\x42\x00\x0f\x00\x44\x00\x1b\x00\x1c\x00\x1d\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x12\x00\x28\x00\x29\x00\x2a\x00\x0a\x00\x0b\x00\x0c\x00\x2e\x00\x0e\x00\x1b\x00\x1c\x00\x32\x00\x33\x00\x43\x00\x35\x00\x40\x00\x40\x00\x38\x00\x40\x00\x3a\x00\x40\x00\x40\x00\x28\x00\x29\x00\x2a\x00\x43\x00\x41\x00\x42\x00\x2e\x00\x44\x00\x40\x00\x32\x00\x32\x00\x33\x00\x43\x00\x35\x00\x0a\x00\x38\x00\x38\x00\x3a\x00\x3a\x00\x0f\x00\x43\x00\x43\x00\x0a\x00\x04\x00\x41\x00\x41\x00\x42\x00\x0f\x00\x44\x00\x19\x00\x1a\x00\x13\x00\x1c\x00\x37\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x35\x00\x2b\x00\x30\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x0a\x00\x2b\x00\x30\x00\x30\x00\x41\x00\x0f\x00\x2b\x00\x0f\x00\x41\x00\x13\x00\x2b\x00\x3c\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x0d\x00\x2f\x00\x39\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x0a\x00\x41\x00\x39\x00\x39\x00\x2f\x00\x0f\x00\x41\x00\x04\x00\x3c\x00\x13\x00\x3c\x00\x3c\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x41\x00\x05\x00\x41\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x0a\x00\x26\x00\x43\x00\x40\x00\x43\x00\x0f\x00\x37\x00\x43\x00\x2b\x00\x13\x00\x44\x00\x2b\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x41\x00\x2b\x00\x31\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x0a\x00\x26\x00\x32\x00\x05\x00\x0f\x00\x0f\x00\x43\x00\x2b\x00\x38\x00\x13\x00\x3a\x00\x2b\x00\x40\x00\x03\x00\x0a\x00\x19\x00\x1a\x00\x41\x00\x1c\x00\x0f\x00\x41\x00\x38\x00\x38\x00\x13\x00\x0c\x00\x38\x00\x24\x00\x41\x00\x26\x00\x19\x00\x1a\x00\x2f\x00\x1c\x00\x3b\x00\x0a\x00\x2f\x00\x3b\x00\x2b\x00\x37\x00\x0f\x00\x24\x00\x0a\x00\x26\x00\x13\x00\x31\x00\x43\x00\x0f\x00\x1f\x00\x2b\x00\x19\x00\x1a\x00\x02\x00\x1c\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x24\x00\x3c\x00\x26\x00\x20\x00\x21\x00\x22\x00\x23\x00\x0a\x00\x41\x00\x34\x00\x34\x00\x02\x00\x0f\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x39\x00\x39\x00\x0a\x00\x20\x00\x21\x00\x22\x00\x23\x00\x0f\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x2f\x00\x45\x00\x0a\x00\x20\x00\x21\x00\x22\x00\x23\x00\x0f\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x3b\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x30\x00\x3b\x00\x0a\x00\x20\x00\x21\x00\x22\x00\x23\x00\x0f\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x30\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x41\x00\x3a\x00\x0a\x00\x20\x00\x21\x00\x22\x00\x23\x00\x0f\x00\x2b\x00\x34\x00\x45\x00\x2b\x00\x36\x00\x2b\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x45\x00\xff\xff\x0a\x00\x20\x00\x21\x00\x22\x00\x23\x00\x0f\x00\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\xff\xff\xff\xff\x0a\x00\x20\x00\x21\x00\x22\x00\x23\x00\x0f\x00\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\xff\xff\xff\xff\x0a\x00\x20\x00\x21\x00\x22\x00\x23\x00\x0f\x00\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\xff\xff\xff\xff\x0a\x00\x20\x00\x21\x00\x22\x00\x23\x00\x0f\x00\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\xff\xff\xff\xff\x0a\x00\x20\x00\x21\x00\x22\x00\x23\x00\x0f\x00\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\xff\xff\xff\xff\x0a\x00\x20\x00\x21\x00\x22\x00\x23\x00\x0f\x00\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\xff\xff\xff\xff\x0a\x00\x20\x00\x21\x00\x22\x00\x23\x00\x0f\x00\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\xff\xff\xff\xff\x0a\x00\x20\x00\x21\x00\x22\x00\x23\x00\x0f\x00\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\xff\xff\xff\xff\x0a\x00\x20\x00\x21\x00\x22\x00\x23\x00\x0f\x00\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\xff\xff\xff\xff\x0a\x00\x20\x00\x21\x00\x22\x00\x23\x00\x0f\x00\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\xff\xff\xff\xff\x0a\x00\x20\x00\x21\x00\x22\x00\x23\x00\x0f\x00\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\xff\xff\xff\xff\x0a\x00\x20\x00\x21\x00\x22\x00\x23\x00\x0f\x00\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\xff\xff\xff\xff\x0a\x00\x20\x00\x21\x00\x22\x00\x23\x00\x0f\x00\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\xff\xff\xff\xff\x0a\x00\x20\x00\x21\x00\x22\x00\x23\x00\x0f\x00\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\xff\xff\xff\xff\x0a\x00\x20\x00\x21\x00\x22\x00\x23\x00\x0f\x00\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\xff\xff\xff\xff\x0a\x00\x20\x00\x21\x00\x22\x00\x23\x00\x0f\x00\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\xff\xff\xff\xff\x0a\x00\x20\x00\x21\x00\x22\x00\x23\x00\x0f\x00\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\xff\xff\xff\xff\x0a\x00\x20\x00\x21\x00\x22\x00\x23\x00\x0f\x00\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\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\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"#--happyTable :: HappyAddr-happyTable = HappyA# "\x00\x00\xd7\x00\x0e\x02\xaa\x00\xbc\x01\xd7\x00\x01\x02\xb3\x01\x67\x01\x4d\x01\x67\x01\xab\x00\x48\x00\x48\x00\x48\x00\x48\x00\x48\x00\x48\x00\x59\x01\xaf\x01\x05\x00\x06\x00\x07\x00\xa9\x01\xcc\x00\x46\x01\xfd\x01\xfd\x01\x4f\x01\x59\x01\x0d\x02\xc8\x01\xc9\x01\xb1\x01\x15\x02\xd4\x00\x0a\x00\x07\x02\xc8\x01\xc9\x01\xfe\x00\x33\x00\xc1\x01\xc1\x01\xd3\x01\xd3\x01\xd4\x01\xd4\x01\x34\x00\x5b\x01\x05\x00\xab\x00\xaa\x00\xc1\x01\xb6\x00\xc2\x01\xc3\x01\x1d\x02\x1c\x02\x26\x00\x27\x00\xc6\x01\xfc\x00\x0a\x00\x0a\x00\xb0\x01\x35\x00\x1b\x02\x0b\x00\x0b\x00\x36\x00\x37\x00\x38\x00\xb7\x00\xb8\x00\xb9\x00\x39\x00\x7c\x01\x16\x02\x5a\x01\x26\x00\xdb\x00\xdb\x00\x26\x00\x12\x02\xfa\x01\xc8\x01\x05\x02\xfe\x00\x7d\x01\x5a\x01\x5b\x01\xca\x01\x0b\x00\x5c\x01\x5d\x01\x5e\x01\x60\x01\xac\x00\x03\x02\xd5\x01\xff\x00\x0e\x00\x0f\x00\x10\x00\xb0\x00\x12\x00\x08\x00\x19\x02\xf8\x01\x4e\x01\xb4\x01\x1a\x02\x0f\x02\x02\x02\xd8\x00\xd8\x00\x68\x01\xcd\x01\x68\x01\x69\x01\xf7\x01\xb6\x01\x3f\x01\x40\x01\x41\x01\x49\x00\xfe\x01\xfe\x01\xaa\x01\x47\x01\x50\x01\xb2\x01\xff\x01\x00\x02\xb2\x01\x00\x01\x08\x00\xad\x00\xf9\x00\xdc\x00\x01\x01\xc1\x01\x02\x01\xc2\x01\xc3\x01\x03\x01\x26\x00\x04\x01\x05\x01\x13\x02\x06\x01\x07\x01\x08\x01\x09\x01\x0a\x01\x0b\x01\x0c\x01\x0d\x01\xe2\x01\xe4\x00\xe5\x00\xe6\x00\x0e\x01\xe7\x00\x0f\x01\x10\x01\x11\x01\x18\x00\xc1\x01\x12\x01\xd3\x01\x13\x01\x10\x02\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\xbd\x01\x5b\x00\x5c\x00\x19\x00\xfe\x00\x3b\x01\xc8\x01\xc9\x01\x5d\x00\x0b\x00\x0b\x00\xe4\x01\x1a\x00\x1b\x00\x1c\x00\x8d\x01\xc4\x01\xff\x00\x0e\x00\x0f\x00\x10\x00\xb0\x00\x12\x00\x3d\x00\x8e\x01\x1d\x00\x1e\x00\x1f\x00\xaa\x00\xe8\x01\x5b\x01\x20\x00\xa8\x01\xe8\x00\x4d\x01\x21\x00\x22\x00\xe9\x01\x23\x00\x8d\x01\x0a\x00\x24\x00\x5b\x01\x25\x00\x30\x00\x0b\x00\xd8\x01\x33\x00\x8e\x01\xd9\x01\x26\x00\x27\x00\x00\x01\x28\x00\x85\x01\xa8\x01\x5e\x00\x01\x01\xae\x00\x02\x01\xca\x01\x61\x01\x03\x01\x3b\x00\x04\x01\x05\x01\xf1\x01\x06\x01\x07\x01\x08\x01\x09\x01\x0a\x01\x0b\x01\x0c\x01\x0d\x01\x5c\x01\x61\x01\xb8\x01\x26\x00\x0e\x01\xf2\x01\x0f\x01\x10\x01\x11\x01\x26\x00\x27\x00\x12\x01\x5c\x01\x13\x01\x60\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\xfe\x00\x0a\x00\x19\x00\x33\x00\xe4\x01\x0b\x00\x0b\x00\xb9\x01\x63\x01\x64\x01\x34\x00\x1a\x00\x1b\x00\xff\x00\x0e\x00\x0f\x00\x10\x00\xb0\x00\x12\x00\x3d\x00\xd7\x01\x92\x01\x62\x01\x63\x01\x64\x01\x1e\x00\x1f\x00\x53\x00\xe8\x00\xc1\x01\x20\x00\xd3\x01\xd8\x01\x09\x02\x21\x00\x22\x00\xb6\x00\xb0\x01\xea\x00\x26\x00\x3f\x00\xa4\x00\x40\x00\xf5\x01\x5b\x00\x5c\x00\xa5\x00\xa8\x00\x00\x01\x26\x00\x27\x00\x5d\x00\x28\x00\x74\x01\x0a\x00\x02\x01\x2f\x01\xb9\x00\x03\x01\x0b\x00\x04\x01\x05\x01\xf6\x01\x06\x01\x07\x01\x08\x01\x09\x01\x0a\x01\x0b\x01\x0c\x01\x0d\x01\x4f\x00\x8f\x01\x33\x00\xdd\x01\x0e\x01\xe6\x01\x0f\x01\x10\x01\x11\x01\x85\x01\x86\x01\x12\x01\x26\x00\x13\x01\xda\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\xfe\x00\x33\x00\x0a\x00\x33\x00\x33\x00\x0b\x00\x51\x00\x0b\x00\x34\x00\x52\x00\x34\x00\x85\x01\x87\x01\xff\x00\x0e\x00\x0f\x00\x10\x00\xb0\x00\x12\x00\x8e\x01\x8f\x01\x17\x02\x33\x00\x33\x00\x9b\x01\x18\x02\x41\x00\x0a\x00\xe8\x00\x34\x00\x85\x01\x88\x01\x0b\x00\x42\x00\x43\x00\x9e\x01\x44\x00\x80\x01\xea\x00\xf9\x01\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\xa0\x01\xe8\x00\x00\x01\x13\x00\x14\x00\x15\x00\x16\x00\x01\x01\xcd\x00\x02\x01\x81\x01\xea\x00\x03\x01\x53\x00\x04\x01\x05\x01\xa1\x01\x06\x01\x07\x01\x08\x01\x09\x01\x0a\x01\x0b\x01\x0c\x01\x0d\x01\xa3\x01\x11\x02\x33\x00\x48\x00\x0e\x01\xfc\x00\x0f\x01\x10\x01\x11\x01\x34\x00\x26\x00\x12\x01\x46\x00\x13\x01\x4c\x00\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x59\x01\x18\x00\xc8\x01\xf0\x01\xe8\x00\xa4\x00\x1d\x01\x1e\x01\x1f\x01\x5c\x00\xa5\x00\xda\x00\xa4\x01\x82\x01\xea\x00\x20\x01\x21\x01\x22\x01\x23\x01\x15\x02\x24\x01\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x1a\x00\x1b\x00\x33\x00\x2b\x01\xb5\x01\x55\x00\x56\x01\xba\x01\x56\x00\x34\x00\x33\x00\x57\x00\x53\x00\x1d\x00\x1e\x00\x1f\x00\xbf\x01\x34\x00\x2c\x01\x2d\x01\xc0\x01\x33\x00\xbb\x01\x21\x00\x22\x00\x6b\x01\x23\x00\x35\x00\x34\x00\x3f\x00\x6f\x01\x40\x00\x71\x01\xc2\x00\x5a\x01\xe8\x00\x2e\x01\x39\x00\x26\x00\x27\x00\x77\x01\x28\x00\x59\x01\x18\x00\x83\x01\xea\x00\xe8\x00\xa4\x00\x1d\x01\x1e\x01\x1f\x01\x5c\x00\xa5\x00\xa6\x00\x33\x00\xef\x00\xea\x00\x20\x01\x21\x01\x22\x01\x23\x01\x34\x00\x24\x01\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x1a\x00\x1b\x00\x33\x00\x2b\x01\xc6\x01\x7f\x01\xa4\x00\x7a\x01\xc7\x01\x34\x00\x35\x00\xa5\x00\xa7\x00\x1d\x00\x1e\x00\x1f\x00\xc5\x00\xd1\x01\x2c\x01\x2d\x01\x39\x00\xd2\x01\x55\x00\x21\x00\x22\x00\x56\x00\x23\x00\x41\x00\x57\x00\x3f\x00\x58\x00\x40\x00\x59\x00\x90\x01\x5a\x01\xbb\x00\x2e\x01\x44\x00\x26\x00\x27\x00\x92\x01\x28\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\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\x18\x00\xa6\x01\x8b\x01\x33\x00\x94\x01\x1d\x01\x1e\x01\x1f\x01\x5c\x00\xfb\x00\x34\x00\x4a\x00\x16\x00\xfc\x00\x20\x01\x21\x01\x22\x01\x23\x01\x95\x01\x24\x01\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x1a\x00\x1b\x00\xe8\x00\x2b\x01\xa4\x00\xc1\x01\x96\x01\xc2\x01\xe3\x01\xa5\x00\xa8\x00\xf1\x00\xea\x00\x1d\x00\x1e\x00\x1f\x00\x18\x00\x97\x01\x2c\x01\x2d\x01\x89\x01\x8a\x01\x8b\x01\x21\x00\x22\x00\x3c\x01\x23\x00\x3e\x01\x33\x00\x3f\x00\xc1\x01\x40\x00\xd3\x01\x19\x00\xe7\x01\x34\x00\x2e\x01\x42\x01\x26\x00\x27\x00\x44\x01\x28\x00\x1a\x00\x1b\x00\x1c\x00\xfc\x01\xdf\x00\xe0\x00\xe1\x00\xe2\x00\x18\x00\x28\x00\x04\x00\xe8\x00\x45\x01\x1d\x00\x1e\x00\x1f\x00\xf3\x00\xe1\x00\xe2\x00\x20\x00\xe9\x00\xea\x00\x48\x01\x21\x00\x22\x00\x19\x00\x23\x00\x49\x01\x0a\x00\x24\x00\x33\x00\x25\x00\x4a\x01\x0b\x00\x1a\x00\x1b\x00\x1c\x00\x2a\x00\x26\x00\x27\x00\x4b\x01\x28\x00\x18\x00\xb2\x00\x10\x00\x53\x01\xb3\x00\x1d\x00\x1e\x00\x1f\x00\xe4\x00\xe5\x00\xe6\x00\x20\x00\x2d\x00\x33\x00\x2e\x00\x21\x00\x22\x00\x19\x00\x23\x00\x51\x01\x34\x00\x24\x00\x56\x01\x25\x00\x30\x00\xed\x00\x1a\x00\x1b\x00\x1c\x00\x3b\x00\x26\x00\x27\x00\x57\x01\x28\x00\x18\x00\x46\x00\xf7\x00\x47\x00\x41\x00\x1d\x00\x1e\x00\x1f\x00\x26\x00\x27\x00\x26\x00\x20\x00\xbe\x00\xf2\x00\x44\x00\x21\x00\x22\x00\x19\x00\x23\x00\x40\x00\x0a\x00\x24\x00\x33\x00\x25\x00\xeb\x00\x0b\x00\x1a\x00\x1b\x00\x53\x00\xba\x00\x26\x00\x27\x00\x54\x00\x28\x00\x5e\x00\xb2\x00\x10\x00\x04\x00\xb3\x00\x1d\x00\x1e\x00\x1f\x00\x18\x00\x0a\x00\x26\x00\x20\x00\x2d\x00\x09\x02\x2e\x00\x21\x00\x22\x00\x84\xff\x23\x00\x0b\x02\x84\xff\x3f\x00\x0a\x00\x40\x00\x0c\x02\x19\x00\x26\x00\x0a\x00\x0d\x02\x18\x00\x26\x00\x27\x00\x0b\x00\x28\x00\x1a\x00\x1b\x00\x1c\x00\xc1\x01\x26\x00\xc2\x01\xf4\x01\xaf\x00\x0f\x00\x10\x00\xb0\x00\x12\x00\x19\x00\x1d\x00\x1e\x00\x1f\x00\x18\x00\x0a\x00\x07\x02\x20\x00\x8e\x01\x1a\x00\x1b\x00\x21\x00\x22\x00\x8e\x01\x23\x00\xe1\x01\xe2\x01\x24\x00\xe7\x01\x25\x00\x0a\x00\x19\x00\x1d\x00\x1e\x00\x1f\x00\xeb\x01\x26\x00\x27\x00\x20\x00\x28\x00\x1a\x00\x1b\x00\x21\x00\x22\x00\xec\x01\x23\x00\xed\x01\xf0\x01\x3f\x00\x26\x00\x40\x00\xc1\x00\x0a\x00\x1d\x00\x1e\x00\x1f\x00\x18\x00\x26\x00\x27\x00\x20\x00\x28\x00\x26\x00\xf4\x01\x21\x00\x22\x00\x0a\x00\x23\x00\xbf\x01\x26\x00\x3f\x00\xc2\x00\x40\x00\xcc\x01\x19\x00\x0a\x00\x0a\x00\x8e\x01\x18\x00\x26\x00\x27\x00\x0b\x00\x28\x00\x1a\x00\x1b\x00\x1c\x00\xed\x01\xdf\x00\xe0\x00\xe1\x00\xe2\x00\x4e\x00\x10\x00\x4f\x00\x12\x00\x19\x00\x1d\x00\x1e\x00\x1f\x00\xe4\x00\xe5\x00\xe6\x00\x20\x00\xe7\x00\x1a\x00\x1b\x00\x21\x00\x22\x00\xed\x00\x23\x00\xdc\x01\xdd\x01\x24\x00\xdf\x01\x25\x00\xe0\x01\x9d\x01\x1d\x00\x1e\x00\x1f\x00\x94\x01\x26\x00\x27\x00\x20\x00\x28\x00\x9e\x01\x3b\x00\x21\x00\x22\x00\xed\x00\x23\x00\x0a\x00\x3c\x00\x3f\x00\x3d\x00\x40\x00\x0b\x00\xa0\x01\xed\x00\x0a\x00\x79\x01\x26\x00\x26\x00\x27\x00\x0b\x00\x28\x00\x4e\x00\x10\x00\x2a\x00\xb3\x00\x3e\x01\xcf\x00\x0d\x00\x0e\x00\x2c\x00\x10\x00\x11\x00\x12\x00\xa6\x01\x0a\x00\xac\x01\x13\x00\x14\x00\x15\x00\x16\x00\xd0\x00\x32\x01\x2e\x00\x0a\x00\x0a\x00\xad\x01\xae\x01\x26\x00\x0b\x00\x0a\x00\x66\x01\x26\x00\x2a\x00\x0a\x00\x6b\x01\xcf\x00\x0d\x00\x0e\x00\x2c\x00\x10\x00\x11\x00\x12\x00\x6d\x01\x6e\x01\x6f\x01\x13\x00\x14\x00\x15\x00\x16\x00\xd0\x00\xd1\x00\x2e\x00\x29\x00\x26\x00\x71\x01\x73\x01\x74\x01\x0b\x00\x26\x00\x79\x01\x7e\x01\x2a\x00\x7f\x01\x85\x01\x2b\x00\x0d\x00\x0e\x00\x2c\x00\x10\x00\x11\x00\x12\x00\x26\x00\x55\x01\x26\x00\x13\x00\x14\x00\x15\x00\x16\x00\x2d\x00\x0a\x00\x2e\x00\x94\x01\x99\x01\x9a\x01\x0b\x00\x3e\x01\x9b\x01\x0a\x00\x2a\x00\x44\x01\x0a\x00\x30\x00\x0d\x00\x0e\x00\x2c\x00\x10\x00\x11\x00\x12\x00\x26\x00\x0a\x00\x53\x01\x13\x00\x14\x00\x15\x00\x16\x00\x31\x00\x0a\x00\x2e\x00\x3b\x00\x55\x01\x66\x01\x0b\x00\xed\x00\x0a\x00\x46\x00\x2a\x00\x47\x00\x0a\x00\xef\x00\xf1\x00\x0a\x00\xb2\x00\x10\x00\x26\x00\xb3\x00\x0b\x00\x26\x00\xf5\x00\xf6\x00\xba\x00\xe6\x00\xf7\x00\x31\x00\x26\x00\x2e\x00\xb2\x00\x10\x00\x31\x01\xb3\x00\x32\x01\x0a\x00\xd5\x00\xd6\x00\x0a\x00\x52\x00\x0b\x00\x2d\x00\x0a\x00\x2e\x00\x2a\x00\xd7\x00\xed\x00\x0b\x00\xa4\x00\x0a\x00\xb2\x00\x10\x00\xb5\x00\xb3\x00\xfb\x01\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x31\x00\xb6\x00\x2e\x00\x13\x00\x14\x00\x15\x00\x16\x00\x0a\x00\x26\x00\xbd\x00\xc4\x00\xc0\x00\x0b\x00\xfa\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\x04\x02\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\xc7\x00\xc8\x00\x0a\x00\x13\x00\x14\x00\x15\x00\x16\x00\x0b\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xee\x01\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\xc9\x00\xff\xff\x0a\x00\x13\x00\x14\x00\x15\x00\x16\x00\x0b\x00\x66\x01\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xca\x00\xcc\x01\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x96\xff\xcb\x00\x0a\x00\x13\x00\x14\x00\x15\x00\x16\x00\x0b\x00\xf8\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xcc\x00\xce\x01\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x26\x00\x48\x00\x0a\x00\x13\x00\x14\x00\x15\x00\x16\x00\x0b\x00\x0a\x00\x4d\x00\xff\xff\x0a\x00\x53\x00\x0a\x00\xcf\x01\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\xff\xff\x00\x00\x0a\x00\x13\x00\x14\x00\x15\x00\x16\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd0\x01\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x0a\x00\x13\x00\x14\x00\x15\x00\x16\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x01\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x0a\x00\x13\x00\x14\x00\x15\x00\x16\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x01\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x0a\x00\x13\x00\x14\x00\x15\x00\x16\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x75\x01\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x0a\x00\x13\x00\x14\x00\x15\x00\x16\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x76\x01\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x0a\x00\x13\x00\x14\x00\x15\x00\x16\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x01\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x0a\x00\x13\x00\x14\x00\x15\x00\x16\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x01\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x0a\x00\x13\x00\x14\x00\x15\x00\x16\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcd\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x0a\x00\x13\x00\x14\x00\x15\x00\x16\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xce\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x0a\x00\x13\x00\x14\x00\x15\x00\x16\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd2\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x0a\x00\x13\x00\x14\x00\x15\x00\x16\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd9\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x0a\x00\x13\x00\x14\x00\x15\x00\x16\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x0a\x00\x13\x00\x14\x00\x15\x00\x16\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x29\x00\x13\x00\x14\x00\x15\x00\x16\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x0a\x00\x13\x00\x14\x00\x15\x00\x16\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x0a\x00\x13\x00\x14\x00\x15\x00\x16\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc4\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x0a\x00\x13\x00\x14\x00\x15\x00\x16\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x0a\x00\x13\x00\x14\x00\x15\x00\x16\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x16\x00\x34\x01\x35\x01\x36\x01\x37\x01\x38\x01\x39\x01\x3a\x01\x3b\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"#--happyReduceArr = Happy_Data_Array.array (3, 306) [-	(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),-	(131 , happyReduce_131),-	(132 , happyReduce_132),-	(133 , happyReduce_133),-	(134 , happyReduce_134),-	(135 , happyReduce_135),-	(136 , happyReduce_136),-	(137 , happyReduce_137),-	(138 , happyReduce_138),-	(139 , happyReduce_139),-	(140 , happyReduce_140),-	(141 , happyReduce_141),-	(142 , happyReduce_142),-	(143 , happyReduce_143),-	(144 , happyReduce_144),-	(145 , happyReduce_145),-	(146 , happyReduce_146),-	(147 , happyReduce_147),-	(148 , happyReduce_148),-	(149 , happyReduce_149),-	(150 , happyReduce_150),-	(151 , happyReduce_151),-	(152 , happyReduce_152),-	(153 , happyReduce_153),-	(154 , happyReduce_154),-	(155 , happyReduce_155),-	(156 , happyReduce_156),-	(157 , happyReduce_157),-	(158 , happyReduce_158),-	(159 , happyReduce_159),-	(160 , happyReduce_160),-	(161 , happyReduce_161),-	(162 , happyReduce_162),-	(163 , happyReduce_163),-	(164 , happyReduce_164),-	(165 , happyReduce_165),-	(166 , happyReduce_166),-	(167 , happyReduce_167),-	(168 , happyReduce_168),-	(169 , happyReduce_169),-	(170 , happyReduce_170),-	(171 , happyReduce_171),-	(172 , happyReduce_172),-	(173 , happyReduce_173),-	(174 , happyReduce_174),-	(175 , happyReduce_175),-	(176 , happyReduce_176),-	(177 , happyReduce_177),-	(178 , happyReduce_178),-	(179 , happyReduce_179),-	(180 , happyReduce_180),-	(181 , happyReduce_181),-	(182 , happyReduce_182),-	(183 , happyReduce_183),-	(184 , happyReduce_184),-	(185 , happyReduce_185),-	(186 , happyReduce_186),-	(187 , happyReduce_187),-	(188 , happyReduce_188),-	(189 , happyReduce_189),-	(190 , happyReduce_190),-	(191 , happyReduce_191),-	(192 , happyReduce_192),-	(193 , happyReduce_193),-	(194 , happyReduce_194),-	(195 , happyReduce_195),-	(196 , happyReduce_196),-	(197 , happyReduce_197),-	(198 , happyReduce_198),-	(199 , happyReduce_199),-	(200 , happyReduce_200),-	(201 , happyReduce_201),-	(202 , happyReduce_202),-	(203 , happyReduce_203),-	(204 , happyReduce_204),-	(205 , happyReduce_205),-	(206 , happyReduce_206),-	(207 , happyReduce_207),-	(208 , happyReduce_208),-	(209 , happyReduce_209),-	(210 , happyReduce_210),-	(211 , happyReduce_211),-	(212 , happyReduce_212),-	(213 , happyReduce_213),-	(214 , happyReduce_214),-	(215 , happyReduce_215),-	(216 , happyReduce_216),-	(217 , happyReduce_217),-	(218 , happyReduce_218),-	(219 , happyReduce_219),-	(220 , happyReduce_220),-	(221 , happyReduce_221),-	(222 , happyReduce_222),-	(223 , happyReduce_223),-	(224 , happyReduce_224),-	(225 , happyReduce_225),-	(226 , happyReduce_226),-	(227 , happyReduce_227),-	(228 , happyReduce_228),-	(229 , happyReduce_229),-	(230 , happyReduce_230),-	(231 , happyReduce_231),-	(232 , happyReduce_232),-	(233 , happyReduce_233),-	(234 , happyReduce_234),-	(235 , happyReduce_235),-	(236 , happyReduce_236),-	(237 , happyReduce_237),-	(238 , happyReduce_238),-	(239 , happyReduce_239),-	(240 , happyReduce_240),-	(241 , happyReduce_241),-	(242 , happyReduce_242),-	(243 , happyReduce_243),-	(244 , happyReduce_244),-	(245 , happyReduce_245),-	(246 , happyReduce_246),-	(247 , happyReduce_247),-	(248 , happyReduce_248),-	(249 , happyReduce_249),-	(250 , happyReduce_250),-	(251 , happyReduce_251),-	(252 , happyReduce_252),-	(253 , happyReduce_253),-	(254 , happyReduce_254),-	(255 , happyReduce_255),-	(256 , happyReduce_256),-	(257 , happyReduce_257),-	(258 , happyReduce_258),-	(259 , happyReduce_259),-	(260 , happyReduce_260),-	(261 , happyReduce_261),-	(262 , happyReduce_262),-	(263 , happyReduce_263),-	(264 , happyReduce_264),-	(265 , happyReduce_265),-	(266 , happyReduce_266),-	(267 , happyReduce_267),-	(268 , happyReduce_268),-	(269 , happyReduce_269),-	(270 , happyReduce_270),-	(271 , happyReduce_271),-	(272 , happyReduce_272),-	(273 , happyReduce_273),-	(274 , happyReduce_274),-	(275 , happyReduce_275),-	(276 , happyReduce_276),-	(277 , happyReduce_277),-	(278 , happyReduce_278),-	(279 , happyReduce_279),-	(280 , happyReduce_280),-	(281 , happyReduce_281),-	(282 , happyReduce_282),-	(283 , happyReduce_283),-	(284 , happyReduce_284),-	(285 , happyReduce_285),-	(286 , happyReduce_286),-	(287 , happyReduce_287),-	(288 , happyReduce_288),-	(289 , happyReduce_289),-	(290 , happyReduce_290),-	(291 , happyReduce_291),-	(292 , happyReduce_292),-	(293 , happyReduce_293),-	(294 , happyReduce_294),-	(295 , happyReduce_295),-	(296 , happyReduce_296),-	(297 , happyReduce_297),-	(298 , happyReduce_298),-	(299 , happyReduce_299),-	(300 , happyReduce_300),-	(301 , happyReduce_301),-	(302 , happyReduce_302),-	(303 , happyReduce_303),-	(304 , happyReduce_304),-	(305 , happyReduce_305),-	(306 , happyReduce_306)-	]--happy_n_terms = 70 :: Int-happy_n_nonterms = 115 :: Int--happyReduce_3 = happySpecReduce_1  0# happyReduction_3-happyReduction_3 happy_x_1-	 =  case happyOut7 happy_x_1 of { happy_var_1 -> -	happyIn6-		 (reverse happy_var_1-	)}--happyReduce_4 = happySpecReduce_2  1# happyReduction_4-happyReduction_4 happy_x_2-	happy_x_1-	 =  case happyOut7 happy_x_1 of { happy_var_1 -> -	case happyOut8 happy_x_2 of { happy_var_2 -> -	happyIn7-		 (happy_var_2 : happy_var_1-	)}}--happyReduce_5 = happySpecReduce_0  1# happyReduction_5-happyReduction_5  =  happyIn7-		 ([]-	)--happyReduce_6 = happySpecReduce_1  2# happyReduction_6-happyReduction_6 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwLet happy_var_1) -> -	happyIn8-		 (TokKeyword KwLet happy_var_1-	)}--happyReduce_7 = happySpecReduce_1  2# happyReduction_7-happyReduction_7 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwIn happy_var_1) -> -	happyIn8-		 (TokKeyword KwIn happy_var_1-	)}--happyReduce_8 = happySpecReduce_1  2# happyReduction_8-happyReduction_8 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwWhere happy_var_1) -> -	happyIn8-		 (TokKeyword KwWhere happy_var_1-	)}--happyReduce_9 = happySpecReduce_1  2# happyReduction_9-happyReduction_9 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwWith happy_var_1) -> -	happyIn8-		 (TokKeyword KwWith happy_var_1-	)}--happyReduce_10 = happySpecReduce_1  2# happyReduction_10-happyReduction_10 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwRewrite happy_var_1) -> -	happyIn8-		 (TokKeyword KwRewrite happy_var_1-	)}--happyReduce_11 = happySpecReduce_1  2# happyReduction_11-happyReduction_11 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwPostulate happy_var_1) -> -	happyIn8-		 (TokKeyword KwPostulate happy_var_1-	)}--happyReduce_12 = happySpecReduce_1  2# happyReduction_12-happyReduction_12 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwPrimitive happy_var_1) -> -	happyIn8-		 (TokKeyword KwPrimitive happy_var_1-	)}--happyReduce_13 = happySpecReduce_1  2# happyReduction_13-happyReduction_13 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwOpen happy_var_1) -> -	happyIn8-		 (TokKeyword KwOpen happy_var_1-	)}--happyReduce_14 = happySpecReduce_1  2# happyReduction_14-happyReduction_14 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwImport happy_var_1) -> -	happyIn8-		 (TokKeyword KwImport happy_var_1-	)}--happyReduce_15 = happySpecReduce_1  2# happyReduction_15-happyReduction_15 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwUsing happy_var_1) -> -	happyIn8-		 (TokKeyword KwUsing happy_var_1-	)}--happyReduce_16 = happySpecReduce_1  2# happyReduction_16-happyReduction_16 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwHiding happy_var_1) -> -	happyIn8-		 (TokKeyword KwHiding happy_var_1-	)}--happyReduce_17 = happySpecReduce_1  2# happyReduction_17-happyReduction_17 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwRenaming happy_var_1) -> -	happyIn8-		 (TokKeyword KwRenaming happy_var_1-	)}--happyReduce_18 = happySpecReduce_1  2# happyReduction_18-happyReduction_18 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwTo happy_var_1) -> -	happyIn8-		 (TokKeyword KwTo happy_var_1-	)}--happyReduce_19 = happySpecReduce_1  2# happyReduction_19-happyReduction_19 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwPublic happy_var_1) -> -	happyIn8-		 (TokKeyword KwPublic happy_var_1-	)}--happyReduce_20 = happySpecReduce_1  2# happyReduction_20-happyReduction_20 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwModule happy_var_1) -> -	happyIn8-		 (TokKeyword KwModule happy_var_1-	)}--happyReduce_21 = happySpecReduce_1  2# happyReduction_21-happyReduction_21 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwData happy_var_1) -> -	happyIn8-		 (TokKeyword KwData happy_var_1-	)}--happyReduce_22 = happySpecReduce_1  2# happyReduction_22-happyReduction_22 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwCoData happy_var_1) -> -	happyIn8-		 (TokKeyword KwCoData happy_var_1-	)}--happyReduce_23 = happySpecReduce_1  2# happyReduction_23-happyReduction_23 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwRecord happy_var_1) -> -	happyIn8-		 (TokKeyword KwRecord happy_var_1-	)}--happyReduce_24 = happySpecReduce_1  2# happyReduction_24-happyReduction_24 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwConstructor happy_var_1) -> -	happyIn8-		 (TokKeyword KwConstructor happy_var_1-	)}--happyReduce_25 = happySpecReduce_1  2# happyReduction_25-happyReduction_25 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwField happy_var_1) -> -	happyIn8-		 (TokKeyword KwField happy_var_1-	)}--happyReduce_26 = happySpecReduce_1  2# happyReduction_26-happyReduction_26 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwInfix happy_var_1) -> -	happyIn8-		 (TokKeyword KwInfix happy_var_1-	)}--happyReduce_27 = happySpecReduce_1  2# happyReduction_27-happyReduction_27 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwInfixL happy_var_1) -> -	happyIn8-		 (TokKeyword KwInfixL happy_var_1-	)}--happyReduce_28 = happySpecReduce_1  2# happyReduction_28-happyReduction_28 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwInfixR happy_var_1) -> -	happyIn8-		 (TokKeyword KwInfixR happy_var_1-	)}--happyReduce_29 = happySpecReduce_1  2# happyReduction_29-happyReduction_29 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwMutual happy_var_1) -> -	happyIn8-		 (TokKeyword KwMutual happy_var_1-	)}--happyReduce_30 = happySpecReduce_1  2# happyReduction_30-happyReduction_30 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwAbstract happy_var_1) -> -	happyIn8-		 (TokKeyword KwAbstract happy_var_1-	)}--happyReduce_31 = happySpecReduce_1  2# happyReduction_31-happyReduction_31 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwPrivate happy_var_1) -> -	happyIn8-		 (TokKeyword KwPrivate happy_var_1-	)}--happyReduce_32 = happySpecReduce_1  2# happyReduction_32-happyReduction_32 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwProp happy_var_1) -> -	happyIn8-		 (TokKeyword KwProp happy_var_1-	)}--happyReduce_33 = happySpecReduce_1  2# happyReduction_33-happyReduction_33 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwSet happy_var_1) -> -	happyIn8-		 (TokKeyword KwSet happy_var_1-	)}--happyReduce_34 = happySpecReduce_1  2# happyReduction_34-happyReduction_34 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwForall happy_var_1) -> -	happyIn8-		 (TokKeyword KwForall happy_var_1-	)}--happyReduce_35 = happySpecReduce_1  2# happyReduction_35-happyReduction_35 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwSyntax happy_var_1) -> -	happyIn8-		 (TokKeyword KwSyntax happy_var_1-	)}--happyReduce_36 = happySpecReduce_1  2# happyReduction_36-happyReduction_36 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwOPTIONS happy_var_1) -> -	happyIn8-		 (TokKeyword KwOPTIONS happy_var_1-	)}--happyReduce_37 = happySpecReduce_1  2# happyReduction_37-happyReduction_37 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwBUILTIN happy_var_1) -> -	happyIn8-		 (TokKeyword KwBUILTIN happy_var_1-	)}--happyReduce_38 = happySpecReduce_1  2# happyReduction_38-happyReduction_38 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwIMPORT happy_var_1) -> -	happyIn8-		 (TokKeyword KwIMPORT happy_var_1-	)}--happyReduce_39 = happySpecReduce_1  2# happyReduction_39-happyReduction_39 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwCOMPILED happy_var_1) -> -	happyIn8-		 (TokKeyword KwCOMPILED happy_var_1-	)}--happyReduce_40 = happySpecReduce_1  2# happyReduction_40-happyReduction_40 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwCOMPILED_DATA happy_var_1) -> -	happyIn8-		 (TokKeyword KwCOMPILED_DATA happy_var_1-	)}--happyReduce_41 = happySpecReduce_1  2# happyReduction_41-happyReduction_41 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwCOMPILED_TYPE happy_var_1) -> -	happyIn8-		 (TokKeyword KwCOMPILED_TYPE happy_var_1-	)}--happyReduce_42 = happySpecReduce_1  2# happyReduction_42-happyReduction_42 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwCOMPILED_EPIC happy_var_1) -> -	happyIn8-		 (TokKeyword KwCOMPILED_EPIC happy_var_1-	)}--happyReduce_43 = happySpecReduce_1  2# happyReduction_43-happyReduction_43 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwIMPOSSIBLE happy_var_1) -> -	happyIn8-		 (TokKeyword KwIMPOSSIBLE happy_var_1-	)}--happyReduce_44 = happySpecReduce_1  2# happyReduction_44-happyReduction_44 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwETA happy_var_1) -> -	happyIn8-		 (TokKeyword KwETA happy_var_1-	)}--happyReduce_45 = happySpecReduce_1  2# happyReduction_45-happyReduction_45 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwQuoteGoal happy_var_1) -> -	happyIn8-		 (TokKeyword KwQuoteGoal happy_var_1-	)}--happyReduce_46 = happySpecReduce_1  2# happyReduction_46-happyReduction_46 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwQuote happy_var_1) -> -	happyIn8-		 (TokKeyword KwQuote happy_var_1-	)}--happyReduce_47 = happySpecReduce_1  2# happyReduction_47-happyReduction_47 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokSetN happy_var_1) -> -	happyIn8-		 (TokSetN happy_var_1-	)}--happyReduce_48 = happySpecReduce_1  2# happyReduction_48-happyReduction_48 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokTeX happy_var_1) -> -	happyIn8-		 (TokTeX happy_var_1-	)}--happyReduce_49 = happySpecReduce_1  2# happyReduction_49-happyReduction_49 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokComment happy_var_1) -> -	happyIn8-		 (TokComment happy_var_1-	)}--happyReduce_50 = happySpecReduce_1  2# happyReduction_50-happyReduction_50 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokSymbol SymEllipsis happy_var_1) -> -	happyIn8-		 (TokSymbol SymEllipsis happy_var_1-	)}--happyReduce_51 = happySpecReduce_1  2# happyReduction_51-happyReduction_51 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokSymbol SymDot happy_var_1) -> -	happyIn8-		 (TokSymbol SymDot happy_var_1-	)}--happyReduce_52 = happySpecReduce_1  2# happyReduction_52-happyReduction_52 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokSymbol SymSemi happy_var_1) -> -	happyIn8-		 (TokSymbol SymSemi happy_var_1-	)}--happyReduce_53 = happySpecReduce_1  2# happyReduction_53-happyReduction_53 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokSymbol SymColon happy_var_1) -> -	happyIn8-		 (TokSymbol SymColon happy_var_1-	)}--happyReduce_54 = happySpecReduce_1  2# happyReduction_54-happyReduction_54 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokSymbol SymEqual happy_var_1) -> -	happyIn8-		 (TokSymbol SymEqual happy_var_1-	)}--happyReduce_55 = happySpecReduce_1  2# happyReduction_55-happyReduction_55 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokSymbol SymUnderscore happy_var_1) -> -	happyIn8-		 (TokSymbol SymUnderscore happy_var_1-	)}--happyReduce_56 = happySpecReduce_1  2# happyReduction_56-happyReduction_56 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokSymbol SymQuestionMark happy_var_1) -> -	happyIn8-		 (TokSymbol SymQuestionMark happy_var_1-	)}--happyReduce_57 = happySpecReduce_1  2# happyReduction_57-happyReduction_57 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokSymbol SymArrow happy_var_1) -> -	happyIn8-		 (TokSymbol SymArrow happy_var_1-	)}--happyReduce_58 = happySpecReduce_1  2# happyReduction_58-happyReduction_58 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokSymbol SymLambda happy_var_1) -> -	happyIn8-		 (TokSymbol SymLambda happy_var_1-	)}--happyReduce_59 = happySpecReduce_1  2# happyReduction_59-happyReduction_59 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokSymbol SymAs happy_var_1) -> -	happyIn8-		 (TokSymbol SymAs happy_var_1-	)}--happyReduce_60 = happySpecReduce_1  2# happyReduction_60-happyReduction_60 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokSymbol SymBar happy_var_1) -> -	happyIn8-		 (TokSymbol SymBar happy_var_1-	)}--happyReduce_61 = happySpecReduce_1  2# happyReduction_61-happyReduction_61 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokSymbol SymOpenParen happy_var_1) -> -	happyIn8-		 (TokSymbol SymOpenParen happy_var_1-	)}--happyReduce_62 = happySpecReduce_1  2# happyReduction_62-happyReduction_62 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokSymbol SymCloseParen happy_var_1) -> -	happyIn8-		 (TokSymbol SymCloseParen happy_var_1-	)}--happyReduce_63 = happySpecReduce_1  2# happyReduction_63-happyReduction_63 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokSymbol SymOpenBrace happy_var_1) -> -	happyIn8-		 (TokSymbol SymOpenBrace happy_var_1-	)}--happyReduce_64 = happySpecReduce_1  2# happyReduction_64-happyReduction_64 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokSymbol SymCloseBrace happy_var_1) -> -	happyIn8-		 (TokSymbol SymCloseBrace happy_var_1-	)}--happyReduce_65 = happySpecReduce_1  2# happyReduction_65-happyReduction_65 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokSymbol SymOpenVirtualBrace happy_var_1) -> -	happyIn8-		 (TokSymbol SymOpenVirtualBrace happy_var_1-	)}--happyReduce_66 = happySpecReduce_1  2# happyReduction_66-happyReduction_66 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokSymbol SymCloseVirtualBrace happy_var_1) -> -	happyIn8-		 (TokSymbol SymCloseVirtualBrace happy_var_1-	)}--happyReduce_67 = happySpecReduce_1  2# happyReduction_67-happyReduction_67 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokSymbol SymVirtualSemi happy_var_1) -> -	happyIn8-		 (TokSymbol SymVirtualSemi happy_var_1-	)}--happyReduce_68 = happySpecReduce_1  2# happyReduction_68-happyReduction_68 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> -	happyIn8-		 (TokSymbol SymOpenPragma happy_var_1-	)}--happyReduce_69 = happySpecReduce_1  2# happyReduction_69-happyReduction_69 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokSymbol SymClosePragma happy_var_1) -> -	happyIn8-		 (TokSymbol SymClosePragma happy_var_1-	)}--happyReduce_70 = happySpecReduce_1  2# happyReduction_70-happyReduction_70 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokId happy_var_1) -> -	happyIn8-		 (TokId happy_var_1-	)}--happyReduce_71 = happySpecReduce_1  2# happyReduction_71-happyReduction_71 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokQId happy_var_1) -> -	happyIn8-		 (TokQId happy_var_1-	)}--happyReduce_72 = happySpecReduce_1  2# happyReduction_72-happyReduction_72 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokString happy_var_1) -> -	happyIn8-		 (TokString happy_var_1-	)}--happyReduce_73 = happySpecReduce_1  2# happyReduction_73-happyReduction_73 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokLiteral happy_var_1) -> -	happyIn8-		 (TokLiteral happy_var_1-	)}--happyReduce_74 = happySpecReduce_0  3# happyReduction_74-happyReduction_74  =  happyIn9-		 (()-	)--happyReduce_75 = happySpecReduce_2  3# happyReduction_75-happyReduction_75 happy_x_2-	happy_x_1-	 =  happyIn9-		 (()-	)--happyReduce_76 = happySpecReduce_2  4# happyReduction_76-happyReduction_76 happy_x_2-	happy_x_1-	 =  case happyOut11 happy_x_1 of { happy_var_1 -> -	happyIn10-		 (happy_var_1-	)}--happyReduce_77 = happySpecReduce_1  5# happyReduction_77-happyReduction_77 happy_x_1-	 =  case happyOut96 happy_x_1 of { happy_var_1 -> -	happyIn11-		 (([], happy_var_1)-	)}--happyReduce_78 = happySpecReduce_3  5# happyReduction_78-happyReduction_78 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut99 happy_x_2 of { happy_var_2 -> -	case happyOut11 happy_x_3 of { happy_var_3 -> -	happyIn11-		 (let (ps,m) = happy_var_3 in (happy_var_2 : ps, m)-	)}}--happyReduce_79 = happySpecReduce_1  6# happyReduction_79-happyReduction_79 happy_x_1-	 =  happyIn12-		 (()-	)--happyReduce_80 = happyMonadReduce 1# 6# happyReduction_80-happyReduction_80 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (( popContext)-	) (\r -> happyReturn (happyIn12 r))--happyReduce_81 = happySpecReduce_1  7# happyReduction_81-happyReduction_81 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokSymbol SymSemi happy_var_1) -> -	happyIn13-		 (happy_var_1-	)}--happyReduce_82 = happySpecReduce_2  7# happyReduction_82-happyReduction_82 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_2 of { (TokSymbol SymVirtualSemi happy_var_2) -> -	happyIn13-		 (happy_var_2-	)}--happyReduce_83 = happyMonadReduce 0# 8# happyReduction_83-happyReduction_83 (happyRest) tk-	 = happyThen (( pushLexState imp_dir)-	) (\r -> happyReturn (happyIn14 r))--happyReduce_84 = happyMonadReduce 1# 9# happyReduction_84-happyReduction_84 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOutTok happy_x_1 of { (TokLiteral happy_var_1) -> -	( case happy_var_1 of {-		     LitInt _ n	-> return $ fromIntegral n;-		     _		-> fail $ "Expected integer"-		   })}-	) (\r -> happyReturn (happyIn15 r))--happyReduce_85 = happyMonadReduce 1# 10# happyReduction_85-happyReduction_85 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOutTok happy_x_1 of { (TokId happy_var_1) -> -	( mkName happy_var_1)}-	) (\r -> happyReturn (happyIn16 r))--happyReduce_86 = happySpecReduce_2  11# happyReduction_86-happyReduction_86 happy_x_2-	happy_x_1-	 =  case happyOut16 happy_x_1 of { happy_var_1 -> -	case happyOut17 happy_x_2 of { happy_var_2 -> -	happyIn17-		 (happy_var_1 : happy_var_2-	)}}--happyReduce_87 = happySpecReduce_1  11# happyReduction_87-happyReduction_87 happy_x_1-	 =  case happyOut16 happy_x_1 of { happy_var_1 -> -	happyIn17-		 ([happy_var_1]-	)}--happyReduce_88 = happySpecReduce_2  12# happyReduction_88-happyReduction_88 happy_x_2-	happy_x_1-	 =  case happyOut16 happy_x_2 of { happy_var_2 -> -	happyIn18-		 (Arg NotHidden Irrelevant happy_var_2-	)}--happyReduce_89 = happySpecReduce_1  12# happyReduction_89-happyReduction_89 happy_x_1-	 =  case happyOut16 happy_x_1 of { happy_var_1 -> -	happyIn18-		 (defaultArg happy_var_1-	)}--happyReduce_90 = happySpecReduce_2  13# happyReduction_90-happyReduction_90 happy_x_2-	happy_x_1-	 =  case happyOut18 happy_x_1 of { happy_var_1 -> -	case happyOut19 happy_x_2 of { happy_var_2 -> -	happyIn19-		 (happy_var_1 : happy_var_2-	)}}--happyReduce_91 = happySpecReduce_1  13# happyReduction_91-happyReduction_91 happy_x_1-	 =  case happyOut18 happy_x_1 of { happy_var_1 -> -	happyIn19-		 ([happy_var_1]-	)}--happyReduce_92 = happySpecReduce_2  14# happyReduction_92-happyReduction_92 happy_x_2-	happy_x_1-	 =  case happyOut18 happy_x_1 of { happy_var_1 -> -	case happyOut20 happy_x_2 of { happy_var_2 -> -	happyIn20-		 (happy_var_1 : happy_var_2-	)}}--happyReduce_93 = happySpecReduce_1  14# happyReduction_93-happyReduction_93 happy_x_1-	 =  case happyOut18 happy_x_1 of { happy_var_1 -> -	happyIn20-		 ([happy_var_1]-	)}--happyReduce_94 = happyReduce 4# 14# happyReduction_94-happyReduction_94 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut19 happy_x_2 of { happy_var_2 -> -	case happyOut20 happy_x_4 of { happy_var_4 -> -	happyIn20-		 (map hide happy_var_2 ++ happy_var_4-	) `HappyStk` happyRest}}--happyReduce_95 = happySpecReduce_3  14# happyReduction_95-happyReduction_95 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut19 happy_x_2 of { happy_var_2 -> -	happyIn20-		 (map hide happy_var_2-	)}--happyReduce_96 = happyReduce 5# 14# happyReduction_96-happyReduction_96 (happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut17 happy_x_3 of { happy_var_3 -> -	case happyOut20 happy_x_5 of { happy_var_5 -> -	happyIn20-		 (map (Arg Hidden Irrelevant) happy_var_3 ++ happy_var_5-	) `HappyStk` happyRest}}--happyReduce_97 = happyReduce 4# 14# happyReduction_97-happyReduction_97 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut17 happy_x_3 of { happy_var_3 -> -	happyIn20-		 (map (Arg Hidden Irrelevant) happy_var_3-	) `HappyStk` happyRest}--happyReduce_98 = happyMonadReduce 1# 15# happyReduction_98-happyReduction_98 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOutTok happy_x_1 of { (TokQId happy_var_1) -> -	( mkQName happy_var_1)}-	) (\r -> happyReturn (happyIn21 r))--happyReduce_99 = happySpecReduce_1  15# happyReduction_99-happyReduction_99 happy_x_1-	 =  case happyOut16 happy_x_1 of { happy_var_1 -> -	happyIn21-		 (QName happy_var_1-	)}--happyReduce_100 = happySpecReduce_1  16# happyReduction_100-happyReduction_100 happy_x_1-	 =  case happyOut21 happy_x_1 of { happy_var_1 -> -	happyIn22-		 (happy_var_1-	)}--happyReduce_101 = happySpecReduce_1  17# happyReduction_101-happyReduction_101 happy_x_1-	 =  case happyOut16 happy_x_1 of { happy_var_1 -> -	happyIn23-		 (happy_var_1-	)}--happyReduce_102 = happySpecReduce_1  17# happyReduction_102-happyReduction_102 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokSymbol SymUnderscore happy_var_1) -> -	happyIn23-		 (Name (getRange happy_var_1) [Hole]-	)}--happyReduce_103 = happySpecReduce_2  18# happyReduction_103-happyReduction_103 happy_x_2-	happy_x_1-	 =  case happyOut23 happy_x_1 of { happy_var_1 -> -	case happyOut24 happy_x_2 of { happy_var_2 -> -	happyIn24-		 (happy_var_1 : happy_var_2-	)}}--happyReduce_104 = happySpecReduce_1  18# happyReduction_104-happyReduction_104 happy_x_1-	 =  case happyOut23 happy_x_1 of { happy_var_1 -> -	happyIn24-		 ([happy_var_1]-	)}--happyReduce_105 = happyMonadReduce 1# 19# happyReduction_105-happyReduction_105 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut31 happy_x_1 of { happy_var_1 -> -	(-    let getName (Ident (QName x)) = Just x-	getName (Underscore r _)  = Just (Name r [Hole])-	getName _		  = Nothing-    in-    case partition isJust $ map getName happy_var_1 of-	(good, []) -> return $ map fromJust good-	_	   -> fail $ "expected sequence of bound identifiers")}-	) (\r -> happyReturn (happyIn25 r))--happyReduce_106 = happySpecReduce_0  20# happyReduction_106-happyReduction_106  =  happyIn26-		 ([]-	)--happyReduce_107 = happySpecReduce_2  20# happyReduction_107-happyReduction_107 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokString happy_var_1) -> -	case happyOut26 happy_x_2 of { happy_var_2 -> -	happyIn26-		 (snd happy_var_1 : happy_var_2-	)}}--happyReduce_108 = happyMonadReduce 1# 21# happyReduction_108-happyReduction_108 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOutTok happy_x_1 of { (TokString happy_var_1) -> -	( fmap QName (mkName happy_var_1))}-	) (\r -> happyReturn (happyIn27 r))--happyReduce_109 = happySpecReduce_2  22# happyReduction_109-happyReduction_109 happy_x_2-	happy_x_1-	 =  case happyOut38 happy_x_1 of { happy_var_1 -> -	case happyOut28 happy_x_2 of { happy_var_2 -> -	happyIn28-		 (Pi happy_var_1 happy_var_2-	)}}--happyReduce_110 = happySpecReduce_3  22# happyReduction_110-happyReduction_110 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut48 happy_x_2 of { happy_var_2 -> -	case happyOut28 happy_x_3 of { happy_var_3 -> -	happyIn28-		 (forallPi happy_var_2 happy_var_3-	)}}--happyReduce_111 = happySpecReduce_3  22# happyReduction_111-happyReduction_111 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut33 happy_x_1 of { happy_var_1 -> -	case happyOut28 happy_x_3 of { happy_var_3 -> -	happyIn28-		 (Fun (fuseRange happy_var_1 happy_var_3) (RawApp (getRange happy_var_1) happy_var_1) happy_var_3-	)}}--happyReduce_112 = happySpecReduce_1  22# happyReduction_112-happyReduction_112 happy_x_1-	 =  case happyOut29 happy_x_1 of { happy_var_1 -> -	happyIn28-		 (happy_var_1-	)}--happyReduce_113 = happyMonadReduce 1# 23# happyReduction_113-happyReduction_113 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut30 happy_x_1 of { happy_var_1 -> -	( case happy_var_1 of-		      { [e]    -> return e-		      ; e : es -> return $ WithApp (fuseRange e es) e es-		      ; []     -> fail "impossible: empty with expressions"-		      })}-	) (\r -> happyReturn (happyIn29 r))--happyReduce_114 = happySpecReduce_3  24# happyReduction_114-happyReduction_114 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut33 happy_x_1 of { happy_var_1 -> -	case happyOut30 happy_x_3 of { happy_var_3 -> -	happyIn30-		 (RawApp (getRange happy_var_1) happy_var_1 :  happy_var_3-	)}}--happyReduce_115 = happySpecReduce_1  24# happyReduction_115-happyReduction_115 happy_x_1-	 =  case happyOut31 happy_x_1 of { happy_var_1 -> -	happyIn30-		 ([RawApp (getRange happy_var_1) happy_var_1]-	)}--happyReduce_116 = happySpecReduce_1  25# happyReduction_116-happyReduction_116 happy_x_1-	 =  case happyOut32 happy_x_1 of { happy_var_1 -> -	happyIn31-		 ([happy_var_1]-	)}--happyReduce_117 = happySpecReduce_2  25# happyReduction_117-happyReduction_117 happy_x_2-	happy_x_1-	 =  case happyOut34 happy_x_1 of { happy_var_1 -> -	case happyOut31 happy_x_2 of { happy_var_2 -> -	happyIn31-		 (happy_var_1 : happy_var_2-	)}}--happyReduce_118 = happySpecReduce_3  26# happyReduction_118-happyReduction_118 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokSymbol SymLambda happy_var_1) -> -	case happyOut45 happy_x_2 of { happy_var_2 -> -	case happyOut28 happy_x_3 of { happy_var_3 -> -	happyIn32-		 (Lam (fuseRange happy_var_1 happy_var_3) happy_var_2 happy_var_3-	)}}}--happyReduce_119 = happySpecReduce_2  26# happyReduction_119-happyReduction_119 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokSymbol SymLambda happy_var_1) -> -	case happyOut46 happy_x_2 of { happy_var_2 -> -	happyIn32-		 (let (bs, h) = happy_var_2; r = fuseRange happy_var_1 bs in-                                     if null bs then AbsurdLam r h else-                                     Lam r bs (AbsurdLam r h)-	)}}--happyReduce_120 = happyReduce 4# 26# happyReduction_120-happyReduction_120 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { (TokKeyword KwLet happy_var_1) -> -	case happyOut118 happy_x_2 of { happy_var_2 -> -	case happyOut28 happy_x_4 of { happy_var_4 -> -	happyIn32-		 (Let (fuseRange happy_var_1 happy_var_4) happy_var_2 happy_var_4-	) `HappyStk` happyRest}}}--happyReduce_121 = happySpecReduce_1  26# happyReduction_121-happyReduction_121 happy_x_1-	 =  case happyOut34 happy_x_1 of { happy_var_1 -> -	happyIn32-		 (happy_var_1-	)}--happyReduce_122 = happyReduce 4# 26# happyReduction_122-happyReduction_122 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { (TokKeyword KwQuoteGoal happy_var_1) -> -	case happyOut16 happy_x_2 of { happy_var_2 -> -	case happyOut28 happy_x_4 of { happy_var_4 -> -	happyIn32-		 (QuoteGoal (getRange (happy_var_1,happy_var_4)) happy_var_2 happy_var_4-	) `HappyStk` happyRest}}}--happyReduce_123 = happySpecReduce_1  27# happyReduction_123-happyReduction_123 happy_x_1-	 =  case happyOut34 happy_x_1 of { happy_var_1 -> -	happyIn33-		 ([happy_var_1]-	)}--happyReduce_124 = happySpecReduce_2  27# happyReduction_124-happyReduction_124 happy_x_2-	happy_x_1-	 =  case happyOut34 happy_x_1 of { happy_var_1 -> -	case happyOut33 happy_x_2 of { happy_var_2 -> -	happyIn33-		 (happy_var_1 : happy_var_2-	)}}--happyReduce_125 = happySpecReduce_1  28# happyReduction_125-happyReduction_125 happy_x_1-	 =  case happyOut21 happy_x_1 of { happy_var_1 -> -	happyIn34-		 (Ident happy_var_1-	)}--happyReduce_126 = happySpecReduce_1  28# happyReduction_126-happyReduction_126 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokLiteral happy_var_1) -> -	happyIn34-		 (Lit happy_var_1-	)}--happyReduce_127 = happySpecReduce_1  28# happyReduction_127-happyReduction_127 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokSymbol SymQuestionMark happy_var_1) -> -	happyIn34-		 (QuestionMark (getRange happy_var_1) Nothing-	)}--happyReduce_128 = happySpecReduce_1  28# happyReduction_128-happyReduction_128 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokSymbol SymUnderscore happy_var_1) -> -	happyIn34-		 (Underscore (getRange happy_var_1) Nothing-	)}--happyReduce_129 = happySpecReduce_1  28# happyReduction_129-happyReduction_129 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwProp happy_var_1) -> -	happyIn34-		 (Prop (getRange happy_var_1)-	)}--happyReduce_130 = happySpecReduce_1  28# happyReduction_130-happyReduction_130 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwSet happy_var_1) -> -	happyIn34-		 (Set (getRange happy_var_1)-	)}--happyReduce_131 = happySpecReduce_1  28# happyReduction_131-happyReduction_131 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwQuote happy_var_1) -> -	happyIn34-		 (Quote (getRange happy_var_1)-	)}--happyReduce_132 = happySpecReduce_1  28# happyReduction_132-happyReduction_132 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokSetN happy_var_1) -> -	happyIn34-		 (SetN (getRange (fst happy_var_1)) (snd happy_var_1)-	)}--happyReduce_133 = happySpecReduce_3  28# happyReduction_133-happyReduction_133 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokSymbol SymOpenBrace happy_var_1) -> -	case happyOut28 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (TokSymbol SymCloseBrace happy_var_3) -> -	happyIn34-		 (HiddenArg (fuseRange happy_var_1 happy_var_3) (unnamed happy_var_2)-	)}}}--happyReduce_134 = happyReduce 5# 28# happyReduction_134-happyReduction_134 (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 { (TokSymbol SymOpenBrace happy_var_1) -> -	case happyOut16 happy_x_2 of { happy_var_2 -> -	case happyOut28 happy_x_4 of { happy_var_4 -> -	case happyOutTok happy_x_5 of { (TokSymbol SymCloseBrace happy_var_5) -> -	happyIn34-		 (HiddenArg (fuseRange happy_var_1 happy_var_5) (named (show happy_var_2) happy_var_4)-	) `HappyStk` happyRest}}}}--happyReduce_135 = happySpecReduce_3  28# happyReduction_135-happyReduction_135 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokSymbol SymOpenParen happy_var_1) -> -	case happyOut28 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (TokSymbol SymCloseParen happy_var_3) -> -	happyIn34-		 (Paren (fuseRange happy_var_1 happy_var_3) happy_var_2-	)}}}--happyReduce_136 = happySpecReduce_2  28# happyReduction_136-happyReduction_136 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokSymbol SymOpenBrace happy_var_1) -> -	case happyOutTok happy_x_2 of { (TokSymbol SymCloseBrace happy_var_2) -> -	happyIn34-		 (let r = fuseRange happy_var_1 happy_var_2 in HiddenArg r $ unnamed $ Absurd r-	)}}--happyReduce_137 = happySpecReduce_2  28# happyReduction_137-happyReduction_137 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokSymbol SymOpenParen happy_var_1) -> -	case happyOutTok happy_x_2 of { (TokSymbol SymCloseParen happy_var_2) -> -	happyIn34-		 (Absurd (fuseRange happy_var_1 happy_var_2)-	)}}--happyReduce_138 = happySpecReduce_3  28# happyReduction_138-happyReduction_138 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut16 happy_x_1 of { happy_var_1 -> -	case happyOut34 happy_x_3 of { happy_var_3 -> -	happyIn34-		 (As (fuseRange happy_var_1 happy_var_3) happy_var_1 happy_var_3-	)}}--happyReduce_139 = happySpecReduce_2  28# happyReduction_139-happyReduction_139 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokSymbol SymDot happy_var_1) -> -	case happyOut34 happy_x_2 of { happy_var_2 -> -	happyIn34-		 (Dot (fuseRange happy_var_1 happy_var_2) happy_var_2-	)}}--happyReduce_140 = happyReduce 4# 28# happyReduction_140-happyReduction_140 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { (TokKeyword KwRecord happy_var_1) -> -	case happyOut35 happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { (TokSymbol SymCloseBrace happy_var_4) -> -	happyIn34-		 (Rec (getRange (happy_var_1,happy_var_4)) happy_var_3-	) `HappyStk` happyRest}}}--happyReduce_141 = happySpecReduce_0  29# happyReduction_141-happyReduction_141  =  happyIn35-		 ([]-	)--happyReduce_142 = happySpecReduce_1  29# happyReduction_142-happyReduction_142 happy_x_1-	 =  case happyOut36 happy_x_1 of { happy_var_1 -> -	happyIn35-		 (happy_var_1-	)}--happyReduce_143 = happySpecReduce_1  30# happyReduction_143-happyReduction_143 happy_x_1-	 =  case happyOut37 happy_x_1 of { happy_var_1 -> -	happyIn36-		 ([happy_var_1]-	)}--happyReduce_144 = happySpecReduce_3  30# happyReduction_144-happyReduction_144 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut37 happy_x_1 of { happy_var_1 -> -	case happyOut36 happy_x_3 of { happy_var_3 -> -	happyIn36-		 (happy_var_1 : happy_var_3-	)}}--happyReduce_145 = happySpecReduce_3  31# happyReduction_145-happyReduction_145 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut16 happy_x_1 of { happy_var_1 -> -	case happyOut28 happy_x_3 of { happy_var_3 -> -	happyIn37-		 ((happy_var_1, happy_var_3)-	)}}--happyReduce_146 = happySpecReduce_2  32# happyReduction_146-happyReduction_146 happy_x_2-	happy_x_1-	 =  case happyOut39 happy_x_1 of { happy_var_1 -> -	happyIn38-		 (happy_var_1-	)}--happyReduce_147 = happySpecReduce_1  33# happyReduction_147-happyReduction_147 happy_x_1-	 =  case happyOut40 happy_x_1 of { happy_var_1 -> -	happyIn39-		 ({-TeleBind-} happy_var_1-	)}--happyReduce_148 = happySpecReduce_2  34# happyReduction_148-happyReduction_148 happy_x_2-	happy_x_1-	 =  case happyOut41 happy_x_1 of { happy_var_1 -> -	case happyOut40 happy_x_2 of { happy_var_2 -> -	happyIn40-		 (happy_var_1 : happy_var_2-	)}}--happyReduce_149 = happySpecReduce_1  34# happyReduction_149-happyReduction_149 happy_x_1-	 =  case happyOut41 happy_x_1 of { happy_var_1 -> -	happyIn40-		 ([happy_var_1]-	)}--happyReduce_150 = happySpecReduce_3  35# happyReduction_150-happyReduction_150 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokSymbol SymOpenParen happy_var_1) -> -	case happyOut42 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (TokSymbol SymCloseParen happy_var_3) -> -	happyIn41-		 (TypedBindings (fuseRange happy_var_1 happy_var_3) (Arg NotHidden Relevant happy_var_2)-	)}}}--happyReduce_151 = happySpecReduce_3  35# happyReduction_151-happyReduction_151 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokSymbol SymOpenBrace happy_var_1) -> -	case happyOut42 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (TokSymbol SymCloseBrace happy_var_3) -> -	happyIn41-		 (TypedBindings (fuseRange happy_var_1 happy_var_3) (Arg Hidden    Relevant happy_var_2)-	)}}}--happyReduce_152 = happySpecReduce_1  36# happyReduction_152-happyReduction_152 happy_x_1-	 =  case happyOut44 happy_x_1 of { happy_var_1 -> -	happyIn42-		 ([happy_var_1]-	)}--happyReduce_153 = happySpecReduce_3  36# happyReduction_153-happyReduction_153 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut44 happy_x_1 of { happy_var_1 -> -	case happyOut43 happy_x_3 of { happy_var_3 -> -	happyIn42-		 (happy_var_1 : happy_var_3-	)}}--happyReduce_154 = happySpecReduce_1  37# happyReduction_154-happyReduction_154 happy_x_1-	 =  case happyOut42 happy_x_1 of { happy_var_1 -> -	happyIn43-		 (happy_var_1-	)}--happyReduce_155 = happySpecReduce_3  37# happyReduction_155-happyReduction_155 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut28 happy_x_1 of { happy_var_1 -> -	case happyOut43 happy_x_3 of { happy_var_3 -> -	happyIn43-		 (TNoBind happy_var_1 : happy_var_3-	)}}--happyReduce_156 = happySpecReduce_1  37# happyReduction_156-happyReduction_156 happy_x_1-	 =  case happyOut28 happy_x_1 of { happy_var_1 -> -	happyIn43-		 ([TNoBind happy_var_1]-	)}--happyReduce_157 = happySpecReduce_3  38# happyReduction_157-happyReduction_157 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut25 happy_x_1 of { happy_var_1 -> -	case happyOut28 happy_x_3 of { happy_var_3 -> -	happyIn44-		 (TBind (fuseRange happy_var_1 happy_var_3) (map mkBoundName_ happy_var_1) happy_var_3-	)}}--happyReduce_158 = happyMonadReduce 2# 39# happyReduction_158-happyReduction_158 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut47 happy_x_1 of { happy_var_1 -> -	(-      case last happy_var_1 of-        Left _  -> parseError "Absurd lambda cannot have a body."-        _       -> return [ b | Right b <- happy_var_1 ])}-	) (\r -> happyReturn (happyIn45 r))--happyReduce_159 = happyMonadReduce 1# 40# happyReduction_159-happyReduction_159 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut47 happy_x_1 of { happy_var_1 -> -	(-    case last happy_var_1 of-      Right _ -> parseError "Missing body for lambda"-      Left h  -> return ([ b | Right b <- init happy_var_1], h))}-	) (\r -> happyReturn (happyIn46 r))--happyReduce_160 = happySpecReduce_2  41# happyReduction_160-happyReduction_160 happy_x_2-	happy_x_1-	 =  case happyOut51 happy_x_1 of { happy_var_1 -> -	case happyOut47 happy_x_2 of { happy_var_2 -> -	happyIn47-		 (map Right happy_var_1 ++ happy_var_2-	)}}--happyReduce_161 = happySpecReduce_2  41# happyReduction_161-happyReduction_161 happy_x_2-	happy_x_1-	 =  case happyOut41 happy_x_1 of { happy_var_1 -> -	case happyOut47 happy_x_2 of { happy_var_2 -> -	happyIn47-		 (Right (DomainFull happy_var_1) : happy_var_2-	)}}--happyReduce_162 = happySpecReduce_1  41# happyReduction_162-happyReduction_162 happy_x_1-	 =  case happyOut51 happy_x_1 of { happy_var_1 -> -	happyIn47-		 (map Right happy_var_1-	)}--happyReduce_163 = happySpecReduce_1  41# happyReduction_163-happyReduction_163 happy_x_1-	 =  case happyOut41 happy_x_1 of { happy_var_1 -> -	happyIn47-		 ([Right $ DomainFull happy_var_1]-	)}--happyReduce_164 = happySpecReduce_2  41# happyReduction_164-happyReduction_164 happy_x_2-	happy_x_1-	 =  happyIn47-		 ([Left NotHidden]-	)--happyReduce_165 = happySpecReduce_2  41# happyReduction_165-happyReduction_165 happy_x_2-	happy_x_1-	 =  happyIn47-		 ([Left Hidden]-	)--happyReduce_166 = happySpecReduce_2  42# happyReduction_166-happyReduction_166 happy_x_2-	happy_x_1-	 =  case happyOut49 happy_x_1 of { happy_var_1 -> -	happyIn48-		 (happy_var_1-	)}--happyReduce_167 = happySpecReduce_2  43# happyReduction_167-happyReduction_167 happy_x_2-	happy_x_1-	 =  case happyOut51 happy_x_1 of { happy_var_1 -> -	case happyOut49 happy_x_2 of { happy_var_2 -> -	happyIn49-		 (happy_var_1 ++ happy_var_2-	)}}--happyReduce_168 = happySpecReduce_2  43# happyReduction_168-happyReduction_168 happy_x_2-	happy_x_1-	 =  case happyOut41 happy_x_1 of { happy_var_1 -> -	case happyOut49 happy_x_2 of { happy_var_2 -> -	happyIn49-		 (DomainFull happy_var_1 : happy_var_2-	)}}--happyReduce_169 = happySpecReduce_1  43# happyReduction_169-happyReduction_169 happy_x_1-	 =  case happyOut51 happy_x_1 of { happy_var_1 -> -	happyIn49-		 (happy_var_1-	)}--happyReduce_170 = happySpecReduce_1  43# happyReduction_170-happyReduction_170 happy_x_1-	 =  case happyOut41 happy_x_1 of { happy_var_1 -> -	happyIn49-		 ([DomainFull happy_var_1]-	)}--happyReduce_171 = happySpecReduce_2  44# happyReduction_171-happyReduction_171 happy_x_2-	happy_x_1-	 =  case happyOut51 happy_x_1 of { happy_var_1 -> -	case happyOut50 happy_x_2 of { happy_var_2 -> -	happyIn50-		 (happy_var_1 ++ happy_var_2-	)}}--happyReduce_172 = happySpecReduce_2  44# happyReduction_172-happyReduction_172 happy_x_2-	happy_x_1-	 =  case happyOut41 happy_x_1 of { happy_var_1 -> -	case happyOut50 happy_x_2 of { happy_var_2 -> -	happyIn50-		 (DomainFull happy_var_1 : happy_var_2-	)}}--happyReduce_173 = happySpecReduce_0  44# happyReduction_173-happyReduction_173  =  happyIn50-		 ([]-	)--happyReduce_174 = happySpecReduce_1  45# happyReduction_174-happyReduction_174 happy_x_1-	 =  case happyOut23 happy_x_1 of { happy_var_1 -> -	happyIn51-		 ([DomainFree NotHidden $ mkBoundName_ happy_var_1]-	)}--happyReduce_175 = happySpecReduce_3  45# happyReduction_175-happyReduction_175 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut25 happy_x_2 of { happy_var_2 -> -	happyIn51-		 (map (DomainFree Hidden . mkBoundName_) happy_var_2-	)}--happyReduce_176 = happySpecReduce_1  46# happyReduction_176-happyReduction_176 happy_x_1-	 =  case happyOut53 happy_x_1 of { happy_var_1 -> -	happyIn52-		 ((Nothing, happy_var_1)-	)}--happyReduce_177 = happyMonadReduce 3# 46# happyReduction_177-happyReduction_177 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOutTok happy_x_1 of { (TokId happy_var_1) -> -	case happyOut16 happy_x_2 of { happy_var_2 -> -	case happyOut53 happy_x_3 of { happy_var_3 -> -	( isName "as" happy_var_1 >>-                               return (Just (AsName happy_var_2 (getRange (fst happy_var_1))), happy_var_3))}}}-	) (\r -> happyReturn (happyIn52 r))--happyReduce_178 = happyMonadReduce 1# 47# happyReduction_178-happyReduction_178 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut54 happy_x_1 of { happy_var_1 -> -	( verifyImportDirective happy_var_1)}-	) (\r -> happyReturn (happyIn53 r))--happyReduce_179 = happySpecReduce_2  48# happyReduction_179-happyReduction_179 happy_x_2-	happy_x_1-	 =  case happyOut55 happy_x_2 of { happy_var_2 -> -	happyIn54-		 (happy_var_2 { publicOpen = True }-	)}--happyReduce_180 = happySpecReduce_1  48# happyReduction_180-happyReduction_180 happy_x_1-	 =  case happyOut55 happy_x_1 of { happy_var_1 -> -	happyIn54-		 (happy_var_1-	)}--happyReduce_181 = happySpecReduce_2  49# happyReduction_181-happyReduction_181 happy_x_2-	happy_x_1-	 =  case happyOut56 happy_x_1 of { happy_var_1 -> -	case happyOut57 happy_x_2 of { happy_var_2 -> -	happyIn55-		 (ImportDirective (fuseRange (snd happy_var_1) (snd happy_var_2)) (fst happy_var_1) (fst happy_var_2) False-	)}}--happyReduce_182 = happySpecReduce_1  49# happyReduction_182-happyReduction_182 happy_x_1-	 =  case happyOut57 happy_x_1 of { happy_var_1 -> -	happyIn55-		 (ImportDirective (getRange (snd happy_var_1)) (Hiding []) (fst happy_var_1) False-	)}--happyReduce_183 = happySpecReduce_1  49# happyReduction_183-happyReduction_183 happy_x_1-	 =  case happyOut56 happy_x_1 of { happy_var_1 -> -	happyIn55-		 (ImportDirective (getRange (snd happy_var_1)) (fst happy_var_1) [] False-	)}--happyReduce_184 = happySpecReduce_0  49# happyReduction_184-happyReduction_184  =  happyIn55-		 (ImportDirective noRange (Hiding []) [] False-	)--happyReduce_185 = happyReduce 4# 50# happyReduction_185-happyReduction_185 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { (TokKeyword KwUsing happy_var_1) -> -	case happyOut62 happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { (TokSymbol SymCloseParen happy_var_4) -> -	happyIn56-		 ((Using happy_var_3 , fuseRange happy_var_1 happy_var_4)-	) `HappyStk` happyRest}}}--happyReduce_186 = happyReduce 4# 50# happyReduction_186-happyReduction_186 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { (TokKeyword KwHiding happy_var_1) -> -	case happyOut63 happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { (TokSymbol SymCloseParen happy_var_4) -> -	happyIn56-		 ((Hiding happy_var_3 , fuseRange happy_var_1 happy_var_4)-	) `HappyStk` happyRest}}}--happyReduce_187 = happyReduce 4# 51# happyReduction_187-happyReduction_187 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { (TokKeyword KwRenaming happy_var_1) -> -	case happyOut58 happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { (TokSymbol SymCloseParen happy_var_4) -> -	happyIn57-		 ((happy_var_3 , fuseRange happy_var_1 happy_var_4)-	) `HappyStk` happyRest}}}--happyReduce_188 = happySpecReduce_3  52# happyReduction_188-happyReduction_188 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut59 happy_x_1 of { happy_var_1 -> -	case happyOut58 happy_x_3 of { happy_var_3 -> -	happyIn58-		 (happy_var_1 : happy_var_3-	)}}--happyReduce_189 = happySpecReduce_1  52# happyReduction_189-happyReduction_189 happy_x_1-	 =  case happyOut59 happy_x_1 of { happy_var_1 -> -	happyIn58-		 ([happy_var_1]-	)}--happyReduce_190 = happySpecReduce_3  53# happyReduction_190-happyReduction_190 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut60 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (TokKeyword KwTo happy_var_2) -> -	case happyOut16 happy_x_3 of { happy_var_3 -> -	happyIn59-		 (Renaming happy_var_1 happy_var_3 (getRange happy_var_2)-	)}}}--happyReduce_191 = happySpecReduce_2  54# happyReduction_191-happyReduction_191 happy_x_2-	happy_x_1-	 =  case happyOut16 happy_x_2 of { happy_var_2 -> -	happyIn60-		 (ImportedName happy_var_2-	)}--happyReduce_192 = happySpecReduce_3  54# happyReduction_192-happyReduction_192 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut16 happy_x_3 of { happy_var_3 -> -	happyIn60-		 (ImportedModule happy_var_3-	)}--happyReduce_193 = happySpecReduce_1  55# happyReduction_193-happyReduction_193 happy_x_1-	 =  case happyOut16 happy_x_1 of { happy_var_1 -> -	happyIn61-		 (ImportedName happy_var_1-	)}--happyReduce_194 = happySpecReduce_2  55# happyReduction_194-happyReduction_194 happy_x_2-	happy_x_1-	 =  case happyOut16 happy_x_2 of { happy_var_2 -> -	happyIn61-		 (ImportedModule happy_var_2-	)}--happyReduce_195 = happySpecReduce_0  56# happyReduction_195-happyReduction_195  =  happyIn62-		 ([]-	)--happyReduce_196 = happySpecReduce_1  56# happyReduction_196-happyReduction_196 happy_x_1-	 =  case happyOut63 happy_x_1 of { happy_var_1 -> -	happyIn62-		 (happy_var_1-	)}--happyReduce_197 = happySpecReduce_1  57# happyReduction_197-happyReduction_197 happy_x_1-	 =  case happyOut61 happy_x_1 of { happy_var_1 -> -	happyIn63-		 ([happy_var_1]-	)}--happyReduce_198 = happySpecReduce_3  57# happyReduction_198-happyReduction_198 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut61 happy_x_1 of { happy_var_1 -> -	case happyOut63 happy_x_3 of { happy_var_3 -> -	happyIn63-		 (happy_var_1 : happy_var_3-	)}}--happyReduce_199 = happyMonadReduce 3# 58# happyReduction_199-happyReduction_199 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut29 happy_x_1 of { happy_var_1 -> -	case happyOut67 happy_x_2 of { happy_var_2 -> -	case happyOut66 happy_x_3 of { happy_var_3 -> -	( exprToLHS happy_var_1 >>= \p -> return (p happy_var_2 happy_var_3))}}}-	) (\r -> happyReturn (happyIn64 r))--happyReduce_200 = happyReduce 4# 58# happyReduction_200-happyReduction_200 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { (TokSymbol SymEllipsis happy_var_1) -> -	case happyOut65 happy_x_2 of { happy_var_2 -> -	case happyOut67 happy_x_3 of { happy_var_3 -> -	case happyOut66 happy_x_4 of { happy_var_4 -> -	happyIn64-		 (Ellipsis (fuseRange happy_var_1 happy_var_3) happy_var_2 happy_var_3 happy_var_4-	) `HappyStk` happyRest}}}}--happyReduce_201 = happySpecReduce_0  59# happyReduction_201-happyReduction_201  =  happyIn65-		 ([]-	)--happyReduce_202 = happyMonadReduce 3# 59# happyReduction_202-happyReduction_202 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut33 happy_x_2 of { happy_var_2 -> -	case happyOut65 happy_x_3 of { happy_var_3 -> -	( exprToPattern (RawApp (getRange happy_var_2) happy_var_2) >>= \p ->-		   return (p : happy_var_3))}}-	) (\r -> happyReturn (happyIn65 r))--happyReduce_203 = happySpecReduce_0  60# happyReduction_203-happyReduction_203  =  happyIn66-		 ([]-	)--happyReduce_204 = happySpecReduce_2  60# happyReduction_204-happyReduction_204 happy_x_2-	happy_x_1-	 =  case happyOut28 happy_x_2 of { happy_var_2 -> -	happyIn66-		 (case happy_var_2 of { WithApp _ e es -> e : es; e -> [e] }-	)}--happyReduce_205 = happySpecReduce_0  61# happyReduction_205-happyReduction_205  =  happyIn67-		 ([]-	)--happyReduce_206 = happySpecReduce_2  61# happyReduction_206-happyReduction_206 happy_x_2-	happy_x_1-	 =  case happyOut28 happy_x_2 of { happy_var_2 -> -	happyIn67-		 (case happy_var_2 of { WithApp _ e es -> e : es; e -> [e] }-	)}--happyReduce_207 = happySpecReduce_0  62# happyReduction_207-happyReduction_207  =  happyIn68-		 (NoWhere-	)--happyReduce_208 = happySpecReduce_2  62# happyReduction_208-happyReduction_208 happy_x_2-	happy_x_1-	 =  case happyOut118 happy_x_2 of { happy_var_2 -> -	happyIn68-		 (AnyWhere happy_var_2-	)}--happyReduce_209 = happyReduce 4# 62# happyReduction_209-happyReduction_209 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut16 happy_x_2 of { happy_var_2 -> -	case happyOut118 happy_x_4 of { happy_var_4 -> -	happyIn68-		 (SomeWhere happy_var_2 happy_var_4-	) `HappyStk` happyRest}}--happyReduce_210 = happySpecReduce_1  63# happyReduction_210-happyReduction_210 happy_x_1-	 =  case happyOut71 happy_x_1 of { happy_var_1 -> -	happyIn69-		 ([happy_var_1]-	)}--happyReduce_211 = happySpecReduce_1  63# happyReduction_211-happyReduction_211 happy_x_1-	 =  case happyOut80 happy_x_1 of { happy_var_1 -> -	happyIn69-		 (happy_var_1-	)}--happyReduce_212 = happySpecReduce_1  63# happyReduction_212-happyReduction_212 happy_x_1-	 =  case happyOut74 happy_x_1 of { happy_var_1 -> -	happyIn69-		 ([happy_var_1]-	)}--happyReduce_213 = happySpecReduce_1  63# happyReduction_213-happyReduction_213 happy_x_1-	 =  case happyOut76 happy_x_1 of { happy_var_1 -> -	happyIn69-		 ([happy_var_1]-	)}--happyReduce_214 = happySpecReduce_1  63# happyReduction_214-happyReduction_214 happy_x_1-	 =  case happyOut77 happy_x_1 of { happy_var_1 -> -	happyIn69-		 ([happy_var_1]-	)}--happyReduce_215 = happySpecReduce_1  63# happyReduction_215-happyReduction_215 happy_x_1-	 =  case happyOut79 happy_x_1 of { happy_var_1 -> -	happyIn69-		 ([happy_var_1]-	)}--happyReduce_216 = happySpecReduce_1  63# happyReduction_216-happyReduction_216 happy_x_1-	 =  case happyOut81 happy_x_1 of { happy_var_1 -> -	happyIn69-		 ([happy_var_1]-	)}--happyReduce_217 = happySpecReduce_1  63# happyReduction_217-happyReduction_217 happy_x_1-	 =  case happyOut82 happy_x_1 of { happy_var_1 -> -	happyIn69-		 ([happy_var_1]-	)}--happyReduce_218 = happySpecReduce_1  63# happyReduction_218-happyReduction_218 happy_x_1-	 =  case happyOut83 happy_x_1 of { happy_var_1 -> -	happyIn69-		 ([happy_var_1]-	)}--happyReduce_219 = happySpecReduce_1  63# happyReduction_219-happyReduction_219 happy_x_1-	 =  case happyOut84 happy_x_1 of { happy_var_1 -> -	happyIn69-		 ([happy_var_1]-	)}--happyReduce_220 = happySpecReduce_1  63# happyReduction_220-happyReduction_220 happy_x_1-	 =  case happyOut85 happy_x_1 of { happy_var_1 -> -	happyIn69-		 ([happy_var_1]-	)}--happyReduce_221 = happySpecReduce_1  63# happyReduction_221-happyReduction_221 happy_x_1-	 =  case happyOut91 happy_x_1 of { happy_var_1 -> -	happyIn69-		 ([happy_var_1]-	)}--happyReduce_222 = happySpecReduce_1  63# happyReduction_222-happyReduction_222 happy_x_1-	 =  case happyOut94 happy_x_1 of { happy_var_1 -> -	happyIn69-		 ([happy_var_1]-	)}--happyReduce_223 = happySpecReduce_1  63# happyReduction_223-happyReduction_223 happy_x_1-	 =  case happyOut93 happy_x_1 of { happy_var_1 -> -	happyIn69-		 ([happy_var_1]-	)}--happyReduce_224 = happySpecReduce_1  63# happyReduction_224-happyReduction_224 happy_x_1-	 =  case happyOut95 happy_x_1 of { happy_var_1 -> -	happyIn69-		 ([happy_var_1]-	)}--happyReduce_225 = happySpecReduce_1  63# happyReduction_225-happyReduction_225 happy_x_1-	 =  case happyOut98 happy_x_1 of { happy_var_1 -> -	happyIn69-		 ([happy_var_1]-	)}--happyReduce_226 = happySpecReduce_1  63# happyReduction_226-happyReduction_226 happy_x_1-	 =  case happyOut86 happy_x_1 of { happy_var_1 -> -	happyIn69-		 ([happy_var_1]-	)}--happyReduce_227 = happySpecReduce_3  64# happyReduction_227-happyReduction_227 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut17 happy_x_1 of { happy_var_1 -> -	case happyOut28 happy_x_3 of { happy_var_3 -> -	happyIn70-		 (map (flip (TypeSig Relevant) happy_var_3) happy_var_1-	)}}--happyReduce_228 = happyReduce 4# 65# happyReduction_228-happyReduction_228 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut16 happy_x_2 of { happy_var_2 -> -	case happyOut28 happy_x_4 of { happy_var_4 -> -	happyIn71-		 (TypeSig Irrelevant happy_var_2 happy_var_4-	) `HappyStk` happyRest}}--happyReduce_229 = happySpecReduce_3  65# happyReduction_229-happyReduction_229 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut16 happy_x_1 of { happy_var_1 -> -	case happyOut28 happy_x_3 of { happy_var_3 -> -	happyIn71-		 (TypeSig Relevant happy_var_1 happy_var_3-	)}}--happyReduce_230 = happySpecReduce_3  66# happyReduction_230-happyReduction_230 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut19 happy_x_1 of { happy_var_1 -> -	case happyOut28 happy_x_3 of { happy_var_3 -> -	happyIn72-		 (map (\ (Arg _ rel x) -> TypeSig rel x happy_var_3) happy_var_1-	)}}--happyReduce_231 = happySpecReduce_3  67# happyReduction_231-happyReduction_231 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut20 happy_x_1 of { happy_var_1 -> -	case happyOut28 happy_x_3 of { happy_var_3 -> -	happyIn73-		 (map (fmap (flip (TypeSig Relevant) happy_var_3)) happy_var_1-	)}}--happyReduce_232 = happySpecReduce_3  68# happyReduction_232-happyReduction_232 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut64 happy_x_1 of { happy_var_1 -> -	case happyOut75 happy_x_2 of { happy_var_2 -> -	case happyOut68 happy_x_3 of { happy_var_3 -> -	happyIn74-		 (FunClause happy_var_1 happy_var_2 happy_var_3-	)}}}--happyReduce_233 = happySpecReduce_2  69# happyReduction_233-happyReduction_233 happy_x_2-	happy_x_1-	 =  case happyOut28 happy_x_2 of { happy_var_2 -> -	happyIn75-		 (RHS happy_var_2-	)}--happyReduce_234 = happySpecReduce_0  69# happyReduction_234-happyReduction_234  =  happyIn75-		 (AbsurdRHS-	)--happyReduce_235 = happyReduce 7# 70# happyReduction_235-happyReduction_235 (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 happyOutTok happy_x_1 of { (TokKeyword KwData happy_var_1) -> -	case happyOut16 happy_x_2 of { happy_var_2 -> -	case happyOut50 happy_x_3 of { happy_var_3 -> -	case happyOut28 happy_x_5 of { happy_var_5 -> -	case happyOutTok happy_x_6 of { (TokKeyword KwWhere happy_var_6) -> -	case happyOut116 happy_x_7 of { happy_var_7 -> -	happyIn76-		 (Data (getRange (happy_var_1, happy_var_6, happy_var_7)) Inductive happy_var_2 (map addType happy_var_3) happy_var_5 happy_var_7-	) `HappyStk` happyRest}}}}}}--happyReduce_236 = happyReduce 7# 70# happyReduction_236-happyReduction_236 (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 happyOutTok happy_x_1 of { (TokKeyword KwCoData happy_var_1) -> -	case happyOut16 happy_x_2 of { happy_var_2 -> -	case happyOut50 happy_x_3 of { happy_var_3 -> -	case happyOut28 happy_x_5 of { happy_var_5 -> -	case happyOutTok happy_x_6 of { (TokKeyword KwWhere happy_var_6) -> -	case happyOut116 happy_x_7 of { happy_var_7 -> -	happyIn76-		 (Data (getRange (happy_var_1, happy_var_6, happy_var_7)) CoInductive happy_var_2 (map addType happy_var_3) happy_var_5 happy_var_7-	) `HappyStk` happyRest}}}}}}--happyReduce_237 = happyReduce 7# 71# happyReduction_237-happyReduction_237 (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 happyOutTok happy_x_1 of { (TokKeyword KwRecord happy_var_1) -> -	case happyOut16 happy_x_2 of { happy_var_2 -> -	case happyOut50 happy_x_3 of { happy_var_3 -> -	case happyOut28 happy_x_5 of { happy_var_5 -> -	case happyOutTok happy_x_6 of { (TokKeyword KwWhere happy_var_6) -> -	case happyOut117 happy_x_7 of { happy_var_7 -> -	happyIn77-		 (Record (getRange (happy_var_1, happy_var_6, happy_var_7)) happy_var_2 (fst happy_var_7) (map addType happy_var_3) happy_var_5 (snd happy_var_7)-	) `HappyStk` happyRest}}}}}}--happyReduce_238 = happySpecReduce_2  72# happyReduction_238-happyReduction_238 happy_x_2-	happy_x_1-	 =  case happyOut16 happy_x_2 of { happy_var_2 -> -	happyIn78-		 (happy_var_2-	)}--happyReduce_239 = happySpecReduce_3  73# happyReduction_239-happyReduction_239 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwInfix happy_var_1) -> -	case happyOut15 happy_x_2 of { happy_var_2 -> -	case happyOut24 happy_x_3 of { happy_var_3 -> -	happyIn79-		 (Infix (NonAssoc (fuseRange happy_var_1 happy_var_3) happy_var_2) happy_var_3-	)}}}--happyReduce_240 = happySpecReduce_3  73# happyReduction_240-happyReduction_240 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwInfixL happy_var_1) -> -	case happyOut15 happy_x_2 of { happy_var_2 -> -	case happyOut24 happy_x_3 of { happy_var_3 -> -	happyIn79-		 (Infix (LeftAssoc (fuseRange happy_var_1 happy_var_3) happy_var_2) happy_var_3-	)}}}--happyReduce_241 = happySpecReduce_3  73# happyReduction_241-happyReduction_241 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwInfixR happy_var_1) -> -	case happyOut15 happy_x_2 of { happy_var_2 -> -	case happyOut24 happy_x_3 of { happy_var_3 -> -	happyIn79-		 (Infix (RightAssoc (fuseRange happy_var_1 happy_var_3) happy_var_2) happy_var_3-	)}}}--happyReduce_242 = happySpecReduce_2  74# happyReduction_242-happyReduction_242 happy_x_2-	happy_x_1-	 =  case happyOut114 happy_x_2 of { happy_var_2 -> -	happyIn80-		 (let toField (Arg h rel (TypeSig _ x t)) = Field x (Arg h rel t) in map toField happy_var_2-	)}--happyReduce_243 = happySpecReduce_2  75# happyReduction_243-happyReduction_243 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwMutual happy_var_1) -> -	case happyOut118 happy_x_2 of { happy_var_2 -> -	happyIn81-		 (Mutual (fuseRange happy_var_1 happy_var_2) happy_var_2-	)}}--happyReduce_244 = happySpecReduce_2  76# happyReduction_244-happyReduction_244 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwAbstract happy_var_1) -> -	case happyOut118 happy_x_2 of { happy_var_2 -> -	happyIn82-		 (Abstract (fuseRange happy_var_1 happy_var_2) happy_var_2-	)}}--happyReduce_245 = happySpecReduce_2  77# happyReduction_245-happyReduction_245 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwPrivate happy_var_1) -> -	case happyOut118 happy_x_2 of { happy_var_2 -> -	happyIn83-		 (Private (fuseRange happy_var_1 happy_var_2) happy_var_2-	)}}--happyReduce_246 = happySpecReduce_2  78# happyReduction_246-happyReduction_246 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwPostulate happy_var_1) -> -	case happyOut112 happy_x_2 of { happy_var_2 -> -	happyIn84-		 (Postulate (fuseRange happy_var_1 happy_var_2) happy_var_2-	)}}--happyReduce_247 = happySpecReduce_2  79# happyReduction_247-happyReduction_247 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwPrimitive happy_var_1) -> -	case happyOut110 happy_x_2 of { happy_var_2 -> -	happyIn85-		 (Primitive (fuseRange happy_var_1 happy_var_2) happy_var_2-	)}}--happyReduce_248 = happyMonadReduce 5# 80# happyReduction_248-happyReduction_248 (happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut16 happy_x_2 of { happy_var_2 -> -	case happyOut88 happy_x_3 of { happy_var_3 -> -	case happyOut87 happy_x_5 of { happy_var_5 -> -	(-  case happy_var_2 of-    Name _ [_] -> case mkNotation happy_var_3 happy_var_5 of-      Left err -> parseError $ "malformed syntax declaration: " ++ err-      Right n -> return $ Syntax happy_var_2 n-    _ -> parseError "syntax declarations are allowed only for simple names (without holes)")}}}-	) (\r -> happyReturn (happyIn86 r))--happyReduce_249 = happySpecReduce_1  81# happyReduction_249-happyReduction_249 happy_x_1-	 =  case happyOut90 happy_x_1 of { happy_var_1 -> -	happyIn87-		 ([happy_var_1]-	)}--happyReduce_250 = happySpecReduce_2  81# happyReduction_250-happyReduction_250 happy_x_2-	happy_x_1-	 =  case happyOut87 happy_x_1 of { happy_var_1 -> -	case happyOut90 happy_x_2 of { happy_var_2 -> -	happyIn87-		 (happy_var_1 ++ [happy_var_2]-	)}}--happyReduce_251 = happySpecReduce_1  82# happyReduction_251-happyReduction_251 happy_x_1-	 =  case happyOut89 happy_x_1 of { happy_var_1 -> -	happyIn88-		 ([happy_var_1]-	)}--happyReduce_252 = happySpecReduce_2  82# happyReduction_252-happyReduction_252 happy_x_2-	happy_x_1-	 =  case happyOut88 happy_x_1 of { happy_var_1 -> -	case happyOut89 happy_x_2 of { happy_var_2 -> -	happyIn88-		 (happy_var_1 ++ [happy_var_2]-	)}}--happyReduce_253 = happySpecReduce_1  83# happyReduction_253-happyReduction_253 happy_x_1-	 =  case happyOut90 happy_x_1 of { happy_var_1 -> -	happyIn89-		 (ExprHole happy_var_1-	)}--happyReduce_254 = happyReduce 6# 83# happyReduction_254-happyReduction_254 (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 happyOut90 happy_x_3 of { happy_var_3 -> -	case happyOut90 happy_x_5 of { happy_var_5 -> -	happyIn89-		 (LambdaHole happy_var_3 happy_var_5-	) `HappyStk` happyRest}}--happyReduce_255 = happySpecReduce_1  84# happyReduction_255-happyReduction_255 happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokId happy_var_1) -> -	happyIn90-		 (snd happy_var_1-	)}--happyReduce_256 = happyReduce 4# 85# happyReduction_256-happyReduction_256 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { (TokKeyword KwOpen happy_var_1) -> -	case happyOut22 happy_x_2 of { happy_var_2 -> -	case happyOut92 happy_x_3 of { happy_var_3 -> -	case happyOut53 happy_x_4 of { happy_var_4 -> -	happyIn91-		 (let-    { m   = happy_var_2-    ; es  = happy_var_3-    ; dir = happy_var_4-    ; r   = getRange (happy_var_1, m, es, dir)-    } in-    case es of-    { []  -> Open r m dir-    ; _   -> Private r [ ModuleMacro r (noName $ beginningOf $ getRange happy_var_2) []-                           (RawApp (fuseRange m es) (Ident m : es)) DoOpen dir-                       ]-    }-	) `HappyStk` happyRest}}}}--happyReduce_257 = happySpecReduce_0  86# happyReduction_257-happyReduction_257  =  happyIn92-		 ([]-	)--happyReduce_258 = happySpecReduce_2  86# happyReduction_258-happyReduction_258 happy_x_2-	happy_x_1-	 =  case happyOut34 happy_x_1 of { happy_var_1 -> -	case happyOut92 happy_x_2 of { happy_var_2 -> -	happyIn92-		 (happy_var_1 : happy_var_2-	)}}--happyReduce_259 = happyReduce 6# 87# happyReduction_259-happyReduction_259 (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 { (TokKeyword KwModule happy_var_1) -> -	case happyOut16 happy_x_2 of { happy_var_2 -> -	case happyOut50 happy_x_3 of { happy_var_3 -> -	case happyOut28 happy_x_5 of { happy_var_5 -> -	case happyOut53 happy_x_6 of { happy_var_6 -> -	happyIn93-		 (ModuleMacro (getRange (happy_var_1, happy_var_5, happy_var_6)) happy_var_2 (map addType happy_var_3) happy_var_5 DontOpen happy_var_6-	) `HappyStk` happyRest}}}}}--happyReduce_260 = happyReduce 7# 87# happyReduction_260-happyReduction_260 (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 happyOutTok happy_x_1 of { (TokKeyword KwOpen happy_var_1) -> -	case happyOut16 happy_x_3 of { happy_var_3 -> -	case happyOut50 happy_x_4 of { happy_var_4 -> -	case happyOut28 happy_x_6 of { happy_var_6 -> -	case happyOut53 happy_x_7 of { happy_var_7 -> -	happyIn93-		 (ModuleMacro (getRange (happy_var_1, happy_var_6, happy_var_7)) happy_var_3 (map addType happy_var_4) happy_var_6 DoOpen happy_var_7-	) `HappyStk` happyRest}}}}}--happyReduce_261 = happySpecReduce_3  88# happyReduction_261-happyReduction_261 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokKeyword KwImport happy_var_1) -> -	case happyOut22 happy_x_2 of { happy_var_2 -> -	case happyOut52 happy_x_3 of { happy_var_3 -> -	happyIn94-		 (Import (getRange (happy_var_1,happy_var_2,snd happy_var_3)) happy_var_2 (fst happy_var_3) DontOpen (snd happy_var_3)-	)}}}--happyReduce_262 = happyReduce 4# 88# happyReduction_262-happyReduction_262 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { (TokKeyword KwOpen happy_var_1) -> -	case happyOut22 happy_x_3 of { happy_var_3 -> -	case happyOut52 happy_x_4 of { happy_var_4 -> -	happyIn94-		 (Import (getRange (happy_var_1,happy_var_3,snd happy_var_4)) happy_var_3 (fst happy_var_4) DoOpen (snd happy_var_4)-	) `HappyStk` happyRest}}}--happyReduce_263 = happyReduce 5# 89# happyReduction_263-happyReduction_263 (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 { (TokKeyword KwModule happy_var_1) -> -	case happyOut16 happy_x_2 of { happy_var_2 -> -	case happyOut50 happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { (TokKeyword KwWhere happy_var_4) -> -	case happyOut119 happy_x_5 of { happy_var_5 -> -	happyIn95-		 (Module (getRange (happy_var_1,happy_var_4,happy_var_5)) (QName happy_var_2) (map addType happy_var_3) happy_var_5-	) `HappyStk` happyRest}}}}}--happyReduce_264 = happySpecReduce_2  90# happyReduction_264-happyReduction_264 happy_x_2-	happy_x_1-	 =  case happyOut97 happy_x_2 of { happy_var_2 -> -	happyIn96-		 ([happy_var_2]-	)}--happyReduce_265 = happySpecReduce_3  90# happyReduction_265-happyReduction_265 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut94 happy_x_2 of { happy_var_2 -> -	case happyOut96 happy_x_3 of { happy_var_3 -> -	happyIn96-		 (happy_var_2 : happy_var_3-	)}}--happyReduce_266 = happySpecReduce_3  90# happyReduction_266-happyReduction_266 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut91 happy_x_2 of { happy_var_2 -> -	case happyOut96 happy_x_3 of { happy_var_3 -> -	happyIn96-		 (happy_var_2 : happy_var_3-	)}}--happyReduce_267 = happyReduce 5# 91# happyReduction_267-happyReduction_267 (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 { (TokKeyword KwModule happy_var_1) -> -	case happyOut22 happy_x_2 of { happy_var_2 -> -	case happyOut50 happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { (TokKeyword KwWhere happy_var_4) -> -	case happyOut119 happy_x_5 of { happy_var_5 -> -	happyIn97-		 (Module (getRange (happy_var_1,happy_var_4,happy_var_5)) happy_var_2 (map addType happy_var_3) happy_var_5-	) `HappyStk` happyRest}}}}}--happyReduce_268 = happySpecReduce_1  92# happyReduction_268-happyReduction_268 happy_x_1-	 =  case happyOut100 happy_x_1 of { happy_var_1 -> -	happyIn98-		 (Pragma happy_var_1-	)}--happyReduce_269 = happySpecReduce_1  93# happyReduction_269-happyReduction_269 happy_x_1-	 =  case happyOut101 happy_x_1 of { happy_var_1 -> -	happyIn99-		 (happy_var_1-	)}--happyReduce_270 = happySpecReduce_1  94# happyReduction_270-happyReduction_270 happy_x_1-	 =  case happyOut102 happy_x_1 of { happy_var_1 -> -	happyIn100-		 (happy_var_1-	)}--happyReduce_271 = happySpecReduce_1  94# happyReduction_271-happyReduction_271 happy_x_1-	 =  case happyOut103 happy_x_1 of { happy_var_1 -> -	happyIn100-		 (happy_var_1-	)}--happyReduce_272 = happySpecReduce_1  94# happyReduction_272-happyReduction_272 happy_x_1-	 =  case happyOut105 happy_x_1 of { happy_var_1 -> -	happyIn100-		 (happy_var_1-	)}--happyReduce_273 = happySpecReduce_1  94# happyReduction_273-happyReduction_273 happy_x_1-	 =  case happyOut104 happy_x_1 of { happy_var_1 -> -	happyIn100-		 (happy_var_1-	)}--happyReduce_274 = happySpecReduce_1  94# happyReduction_274-happyReduction_274 happy_x_1-	 =  case happyOut106 happy_x_1 of { happy_var_1 -> -	happyIn100-		 (happy_var_1-	)}--happyReduce_275 = happySpecReduce_1  94# happyReduction_275-happyReduction_275 happy_x_1-	 =  case happyOut108 happy_x_1 of { happy_var_1 -> -	happyIn100-		 (happy_var_1-	)}--happyReduce_276 = happySpecReduce_1  94# happyReduction_276-happyReduction_276 happy_x_1-	 =  case happyOut109 happy_x_1 of { happy_var_1 -> -	happyIn100-		 (happy_var_1-	)}--happyReduce_277 = happySpecReduce_1  94# happyReduction_277-happyReduction_277 happy_x_1-	 =  case happyOut107 happy_x_1 of { happy_var_1 -> -	happyIn100-		 (happy_var_1-	)}--happyReduce_278 = happyReduce 4# 95# happyReduction_278-happyReduction_278 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> -	case happyOut26 happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { (TokSymbol SymClosePragma happy_var_4) -> -	happyIn101-		 (OptionsPragma (fuseRange happy_var_1 happy_var_4) happy_var_3-	) `HappyStk` happyRest}}}--happyReduce_279 = happyReduce 5# 96# happyReduction_279-happyReduction_279 (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 { (TokSymbol SymOpenPragma happy_var_1) -> -	case happyOutTok happy_x_3 of { (TokString happy_var_3) -> -	case happyOut27 happy_x_4 of { happy_var_4 -> -	case happyOutTok happy_x_5 of { (TokSymbol SymClosePragma happy_var_5) -> -	happyIn102-		 (BuiltinPragma (fuseRange happy_var_1 happy_var_5) (snd happy_var_3) (Ident happy_var_4)-	) `HappyStk` happyRest}}}}--happyReduce_280 = happyReduce 5# 97# happyReduction_280-happyReduction_280 (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 { (TokSymbol SymOpenPragma happy_var_1) -> -	case happyOut27 happy_x_3 of { happy_var_3 -> -	case happyOut26 happy_x_4 of { happy_var_4 -> -	case happyOutTok happy_x_5 of { (TokSymbol SymClosePragma happy_var_5) -> -	happyIn103-		 (CompiledPragma (fuseRange happy_var_1 happy_var_5) happy_var_3 (unwords happy_var_4)-	) `HappyStk` happyRest}}}}--happyReduce_281 = happyReduce 5# 98# happyReduction_281-happyReduction_281 (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 { (TokSymbol SymOpenPragma happy_var_1) -> -	case happyOut27 happy_x_3 of { happy_var_3 -> -	case happyOut26 happy_x_4 of { happy_var_4 -> -	case happyOutTok happy_x_5 of { (TokSymbol SymClosePragma happy_var_5) -> -	happyIn104-		 (CompiledTypePragma (fuseRange happy_var_1 happy_var_5) happy_var_3 (unwords happy_var_4)-	) `HappyStk` happyRest}}}}--happyReduce_282 = happyReduce 6# 99# happyReduction_282-happyReduction_282 (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 { (TokSymbol SymOpenPragma happy_var_1) -> -	case happyOut27 happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { (TokString happy_var_4) -> -	case happyOut26 happy_x_5 of { happy_var_5 -> -	case happyOutTok happy_x_6 of { (TokSymbol SymClosePragma happy_var_6) -> -	happyIn105-		 (CompiledDataPragma (fuseRange happy_var_1 happy_var_6) happy_var_3 (snd happy_var_4) happy_var_5-	) `HappyStk` happyRest}}}}}--happyReduce_283 = happyReduce 5# 100# happyReduction_283-happyReduction_283 (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 { (TokSymbol SymOpenPragma happy_var_1) -> -	case happyOut27 happy_x_3 of { happy_var_3 -> -	case happyOut26 happy_x_4 of { happy_var_4 -> -	case happyOutTok happy_x_5 of { (TokSymbol SymClosePragma happy_var_5) -> -	happyIn106-		 (CompiledEpicPragma (fuseRange happy_var_1 happy_var_5) happy_var_3 (unwords happy_var_4)-	) `HappyStk` happyRest}}}}--happyReduce_284 = happyReduce 4# 101# happyReduction_284-happyReduction_284 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> -	case happyOut27 happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { (TokSymbol SymClosePragma happy_var_4) -> -	happyIn107-		 (EtaPragma (fuseRange happy_var_1 happy_var_4) happy_var_3-	) `HappyStk` happyRest}}}--happyReduce_285 = happyMonadReduce 4# 102# happyReduction_285-happyReduction_285 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> -	case happyOutTok happy_x_3 of { (TokString happy_var_3) -> -	case happyOutTok happy_x_4 of { (TokSymbol SymClosePragma happy_var_4) -> -	( let s = snd happy_var_3 in-       if validHaskellModuleName s-       then return $ ImportPragma (fuseRange happy_var_1 happy_var_4) s-       else parseError $ "Malformed module name: " ++ s ++ ".")}}}-	) (\r -> happyReturn (happyIn108 r))--happyReduce_286 = happySpecReduce_3  103# happyReduction_286-happyReduction_286 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> -	case happyOutTok happy_x_3 of { (TokSymbol SymClosePragma happy_var_3) -> -	happyIn109-		 (ImpossiblePragma (fuseRange happy_var_1 happy_var_3)-	)}}--happyReduce_287 = happyReduce 5# 104# happyReduction_287-happyReduction_287 (happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut111 happy_x_3 of { happy_var_3 -> -	happyIn110-		 (reverse happy_var_3-	) `HappyStk` happyRest}--happyReduce_288 = happyReduce 4# 105# happyReduction_288-happyReduction_288 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut111 happy_x_1 of { happy_var_1 -> -	case happyOut70 happy_x_4 of { happy_var_4 -> -	happyIn111-		 (reverse happy_var_4 ++ happy_var_1-	) `HappyStk` happyRest}}--happyReduce_289 = happySpecReduce_2  105# happyReduction_289-happyReduction_289 happy_x_2-	happy_x_1-	 =  case happyOut70 happy_x_2 of { happy_var_2 -> -	happyIn111-		 (reverse happy_var_2-	)}--happyReduce_290 = happyReduce 5# 106# happyReduction_290-happyReduction_290 (happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut113 happy_x_3 of { happy_var_3 -> -	happyIn112-		 (reverse happy_var_3-	) `HappyStk` happyRest}--happyReduce_291 = happyReduce 4# 107# happyReduction_291-happyReduction_291 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut113 happy_x_1 of { happy_var_1 -> -	case happyOut72 happy_x_4 of { happy_var_4 -> -	happyIn113-		 (reverse happy_var_4 ++ happy_var_1-	) `HappyStk` happyRest}}--happyReduce_292 = happySpecReduce_2  107# happyReduction_292-happyReduction_292 happy_x_2-	happy_x_1-	 =  case happyOut72 happy_x_2 of { happy_var_2 -> -	happyIn113-		 (reverse happy_var_2-	)}--happyReduce_293 = happyReduce 5# 108# happyReduction_293-happyReduction_293 (happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut115 happy_x_3 of { happy_var_3 -> -	happyIn114-		 (reverse happy_var_3-	) `HappyStk` happyRest}--happyReduce_294 = happyReduce 4# 109# happyReduction_294-happyReduction_294 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut115 happy_x_1 of { happy_var_1 -> -	case happyOut73 happy_x_4 of { happy_var_4 -> -	happyIn115-		 (reverse happy_var_4 ++ happy_var_1-	) `HappyStk` happyRest}}--happyReduce_295 = happySpecReduce_2  109# happyReduction_295-happyReduction_295 happy_x_2-	happy_x_1-	 =  case happyOut73 happy_x_2 of { happy_var_2 -> -	happyIn115-		 (reverse happy_var_2-	)}--happyReduce_296 = happyReduce 4# 110# happyReduction_296-happyReduction_296 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = happyIn116-		 ([]-	) `HappyStk` happyRest--happyReduce_297 = happySpecReduce_1  110# happyReduction_297-happyReduction_297 happy_x_1-	 =  case happyOut110 happy_x_1 of { happy_var_1 -> -	happyIn116-		 (happy_var_1-	)}--happyReduce_298 = happyReduce 4# 111# happyReduction_298-happyReduction_298 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = happyIn117-		 ((Nothing, [])-	) `HappyStk` happyRest--happyReduce_299 = happyReduce 6# 111# happyReduction_299-happyReduction_299 (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 happyOut78 happy_x_4 of { happy_var_4 -> -	happyIn117-		 ((Just happy_var_4, [])-	) `HappyStk` happyRest}--happyReduce_300 = happyReduce 8# 111# happyReduction_300-happyReduction_300 (happy_x_8 `HappyStk`-	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 happyOut78 happy_x_4 of { happy_var_4 -> -	case happyOut120 happy_x_6 of { happy_var_6 -> -	happyIn117-		 ((Just happy_var_4, reverse happy_var_6)-	) `HappyStk` happyRest}}--happyReduce_301 = happyReduce 5# 111# happyReduction_301-happyReduction_301 (happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut120 happy_x_3 of { happy_var_3 -> -	happyIn117-		 ((Nothing, reverse happy_var_3)-	) `HappyStk` happyRest}--happyReduce_302 = happyReduce 5# 112# happyReduction_302-happyReduction_302 (happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut120 happy_x_3 of { happy_var_3 -> -	happyIn118-		 (reverse happy_var_3-	) `HappyStk` happyRest}--happyReduce_303 = happyReduce 4# 113# happyReduction_303-happyReduction_303 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = happyIn119-		 ([]-	) `HappyStk` happyRest--happyReduce_304 = happySpecReduce_1  113# happyReduction_304-happyReduction_304 happy_x_1-	 =  case happyOut118 happy_x_1 of { happy_var_1 -> -	happyIn119-		 (happy_var_1-	)}--happyReduce_305 = happyReduce 4# 114# happyReduction_305-happyReduction_305 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut120 happy_x_1 of { happy_var_1 -> -	case happyOut69 happy_x_4 of { happy_var_4 -> -	happyIn120-		 (reverse happy_var_4 ++ happy_var_1-	) `HappyStk` happyRest}}--happyReduce_306 = happySpecReduce_2  114# happyReduction_306-happyReduction_306 happy_x_2-	happy_x_1-	 =  case happyOut69 happy_x_2 of { happy_var_2 -> -	happyIn120-		 (reverse happy_var_2-	)}--happyNewToken action sts stk-	= lexer(\tk -> -	let cont i = happyDoAction i tk action sts stk in-	case tk of {-	TokEOF -> happyDoAction 69# tk action sts stk;-	TokKeyword KwLet happy_dollar_dollar -> cont 1#;-	TokKeyword KwIn happy_dollar_dollar -> cont 2#;-	TokKeyword KwWhere happy_dollar_dollar -> cont 3#;-	TokKeyword KwWith happy_dollar_dollar -> cont 4#;-	TokKeyword KwRewrite happy_dollar_dollar -> cont 5#;-	TokKeyword KwPostulate happy_dollar_dollar -> cont 6#;-	TokKeyword KwPrimitive happy_dollar_dollar -> cont 7#;-	TokKeyword KwOpen happy_dollar_dollar -> cont 8#;-	TokKeyword KwImport happy_dollar_dollar -> cont 9#;-	TokKeyword KwUsing happy_dollar_dollar -> cont 10#;-	TokKeyword KwHiding happy_dollar_dollar -> cont 11#;-	TokKeyword KwRenaming happy_dollar_dollar -> cont 12#;-	TokKeyword KwTo happy_dollar_dollar -> cont 13#;-	TokKeyword KwPublic happy_dollar_dollar -> cont 14#;-	TokKeyword KwModule happy_dollar_dollar -> cont 15#;-	TokKeyword KwData happy_dollar_dollar -> cont 16#;-	TokKeyword KwCoData happy_dollar_dollar -> cont 17#;-	TokKeyword KwRecord happy_dollar_dollar -> cont 18#;-	TokKeyword KwConstructor happy_dollar_dollar -> cont 19#;-	TokKeyword KwField happy_dollar_dollar -> cont 20#;-	TokKeyword KwInfix happy_dollar_dollar -> cont 21#;-	TokKeyword KwInfixL happy_dollar_dollar -> cont 22#;-	TokKeyword KwInfixR happy_dollar_dollar -> cont 23#;-	TokKeyword KwMutual happy_dollar_dollar -> cont 24#;-	TokKeyword KwAbstract happy_dollar_dollar -> cont 25#;-	TokKeyword KwPrivate happy_dollar_dollar -> cont 26#;-	TokKeyword KwProp happy_dollar_dollar -> cont 27#;-	TokKeyword KwSet happy_dollar_dollar -> cont 28#;-	TokKeyword KwForall happy_dollar_dollar -> cont 29#;-	TokKeyword KwSyntax happy_dollar_dollar -> cont 30#;-	TokKeyword KwOPTIONS happy_dollar_dollar -> cont 31#;-	TokKeyword KwBUILTIN happy_dollar_dollar -> cont 32#;-	TokKeyword KwIMPORT happy_dollar_dollar -> cont 33#;-	TokKeyword KwIMPOSSIBLE happy_dollar_dollar -> cont 34#;-	TokKeyword KwETA happy_dollar_dollar -> cont 35#;-	TokKeyword KwCOMPILED happy_dollar_dollar -> cont 36#;-	TokKeyword KwCOMPILED_DATA happy_dollar_dollar -> cont 37#;-	TokKeyword KwCOMPILED_TYPE happy_dollar_dollar -> cont 38#;-	TokKeyword KwCOMPILED_EPIC happy_dollar_dollar -> cont 39#;-	TokKeyword KwQuoteGoal happy_dollar_dollar -> cont 40#;-	TokKeyword KwQuote happy_dollar_dollar -> cont 41#;-	TokSetN happy_dollar_dollar -> cont 42#;-	TokTeX happy_dollar_dollar -> cont 43#;-	TokComment happy_dollar_dollar -> cont 44#;-	TokSymbol SymEllipsis happy_dollar_dollar -> cont 45#;-	TokSymbol SymDot happy_dollar_dollar -> cont 46#;-	TokSymbol SymSemi happy_dollar_dollar -> cont 47#;-	TokSymbol SymColon happy_dollar_dollar -> cont 48#;-	TokSymbol SymEqual happy_dollar_dollar -> cont 49#;-	TokSymbol SymUnderscore happy_dollar_dollar -> cont 50#;-	TokSymbol SymQuestionMark happy_dollar_dollar -> cont 51#;-	TokSymbol SymArrow happy_dollar_dollar -> cont 52#;-	TokSymbol SymLambda happy_dollar_dollar -> cont 53#;-	TokSymbol SymAs happy_dollar_dollar -> cont 54#;-	TokSymbol SymBar happy_dollar_dollar -> cont 55#;-	TokSymbol SymOpenParen happy_dollar_dollar -> cont 56#;-	TokSymbol SymCloseParen happy_dollar_dollar -> cont 57#;-	TokSymbol SymOpenBrace happy_dollar_dollar -> cont 58#;-	TokSymbol SymCloseBrace happy_dollar_dollar -> cont 59#;-	TokSymbol SymOpenVirtualBrace happy_dollar_dollar -> cont 60#;-	TokSymbol SymCloseVirtualBrace happy_dollar_dollar -> cont 61#;-	TokSymbol SymVirtualSemi happy_dollar_dollar -> cont 62#;-	TokSymbol SymOpenPragma happy_dollar_dollar -> cont 63#;-	TokSymbol SymClosePragma happy_dollar_dollar -> cont 64#;-	TokId happy_dollar_dollar -> cont 65#;-	TokQId happy_dollar_dollar -> cont 66#;-	TokString happy_dollar_dollar -> cont 67#;-	TokLiteral happy_dollar_dollar -> cont 68#;-	_ -> happyError' tk-	})--happyError_ tk = happyError' tk--happyThen :: () => Parser a -> (a -> Parser b) -> Parser b-happyThen = (>>=)-happyReturn :: () => a -> Parser a-happyReturn = (return)-happyThen1 = happyThen-happyReturn1 :: () => a -> Parser a-happyReturn1 = happyReturn-happyError' :: () => (Token) -> Parser a-happyError' tk = (\token -> happyError) tk--tokensParser = happySomeParser where-  happySomeParser = happyThen (happyParse 0#) (\x -> happyReturn (happyOut6 x))--exprParser = happySomeParser where-  happySomeParser = happyThen (happyParse 1#) (\x -> happyReturn (happyOut28 x))--moduleParser = happySomeParser where-  happySomeParser = happyThen (happyParse 2#) (\x -> happyReturn (happyOut10 x))--happySeq = happyDontSeq---{---------------------------------------------------------------------------    Parsers- --------------------------------------------------------------------------}---- | Parse the token stream. Used by the TeX compiler.-tokensParser :: Parser [Token]---- | Parse an expression. Could be used in interactions.-exprParser :: Parser Expr---- | Parse a module.-moduleParser :: Parser Module---{---------------------------------------------------------------------------    Happy stuff- --------------------------------------------------------------------------}---- | Required by Happy.-happyError :: Parser a-happyError = parseError "Parse error"---{---------------------------------------------------------------------------    Utility functions- --------------------------------------------------------------------------}---- | Create a name from a string.--mkName :: (Interval, String) -> Parser Name-mkName (i, s) = do-    let xs = parts s-    mapM_ isValidId xs-    unless (alternating xs) $ fail $ "a name cannot contain two consecutive underscores"-    return $ Name (getRange i) xs-    where-        parts :: String -> [NamePart]-        parts ""        = []-        parts ('_' : s) = Hole : parts s-        parts s         = Id x : parts s'-          where (x, s') = break (== '_') s--	isValidId Hole   = return ()-	isValidId (Id x) = case parse defaultParseFlags [0] (lexer return) x of-	    ParseOk _ (TokId _) -> return ()-	    _			-> fail $ "in the name " ++ s ++ ", the part " ++ x ++ " is not valid"--	-- we know that there are no two Ids in a row-	alternating (Hole : Hole : _) = False-	alternating (_ : xs)	      = alternating xs-	alternating []		      = True---- | Create a qualified name from a list of strings-mkQName :: [(Interval, String)] -> Parser QName-mkQName ss = do-    xs <- mapM mkName ss-    return $ foldr Qual (QName $ last xs) (init xs)---- | Match a particular name.-isName :: String -> (Interval, String) -> Parser ()-isName s (_,s')-    | s == s'	= return ()-    | otherwise	= fail $ "expected " ++ s ++ ", found " ++ s'---- | Build a forall pi (forall x y z -> ...)-forallPi :: [LamBinding] -> Expr -> Expr-forallPi bs e = Pi (map addType bs) e---- | Converts lambda bindings to typed bindings.-addType :: LamBinding -> TypedBindings-addType (DomainFull b)	 = b-addType (DomainFree h x) = TypedBindings r $ Arg h Relevant [TBind r [x] $ Underscore r Nothing]-  where r = getRange x---- | Check that an import directive doesn't contain repeated names-verifyImportDirective :: ImportDirective -> Parser ImportDirective-verifyImportDirective i =-    case filter ((>1) . length)-	 $ group-	 $ sort xs-    of-	[]  -> return i-	yss -> let Just pos = rStart $ getRange $ head $ concat yss in-               parseErrorAt pos $-		"repeated name" ++ s ++ " in import directive: " ++-		concat (intersperse ", " $ map (show . head) yss)-	    where-		s = case yss of-			[_] -> ""-			_   -> "s"-    where-	xs = names (usingOrHiding i) ++ map renFrom (renaming i)-	names (Using xs)    = xs-	names (Hiding xs)   = xs---- | Breaks up a string into substrings. Returns every maximal--- subsequence of zero or more characters distinct from @'.'@.------ > splitOnDots ""         == [""]--- > splitOnDots "foo.bar"  == ["foo", "bar"]--- > splitOnDots ".foo.bar" == ["", "foo", "bar"]--- > splitOnDots "foo.bar." == ["foo", "bar", ""]--- > splitOnDots "foo..bar" == ["foo", "", "bar"]-splitOnDots :: String -> [String]-splitOnDots ""        = [""]-splitOnDots ('.' : s) = [] : splitOnDots s-splitOnDots (c   : s) = case splitOnDots s of-  p : ps -> (c : p) : ps--prop_splitOnDots = and-  [ splitOnDots ""         == [""]-  , splitOnDots "foo.bar"  == ["foo", "bar"]-  , splitOnDots ".foo.bar" == ["", "foo", "bar"]-  , splitOnDots "foo.bar." == ["foo", "bar", ""]-  , splitOnDots "foo..bar" == ["foo", "", "bar"]-  ]---- | Returns 'True' iff the name is a valid Haskell (hierarchical)--- module name.-validHaskellModuleName :: String -> Bool-validHaskellModuleName = all ok . splitOnDots-  where-  -- Checks if a dot-less module name is well-formed.-  ok :: String -> Bool-  ok []      = False-  ok (c : s) =-    isUpper c &&-    all (\c -> isLower c || c == '_' ||-               isUpper c ||-               generalCategory c == DecimalNumber ||-               c == '\'')-        s--{---------------------------------------------------------------------------    Patterns- --------------------------------------------------------------------------}---- | Turn an expression into a left hand side.-exprToLHS :: Expr -> Parser ([Expr] -> [Expr] -> LHS)-exprToLHS e = case e of-  WithApp r e es -> LHS <$> exprToPattern e <*> mapM exprToPattern es-  _		 -> LHS <$> exprToPattern e <*> return []---- | Turn an expression into a pattern. Fails if the expression is not a---   valid pattern.-exprToPattern :: Expr -> Parser Pattern-exprToPattern e =-    case e of-	Ident x			-> return $ IdentP x-	App _ e1 e2		-> AppP <$> exprToPattern e1-					<*> T.mapM (T.mapM exprToPattern) e2-	Paren r e		-> ParenP r-					<$> exprToPattern e-	Underscore r _		-> return $ WildP r-	Absurd r		-> return $ AbsurdP r-	As r x e		-> AsP r x <$> exprToPattern e-	Dot r (HiddenArg _ e)	-> return $ HiddenP r $ fmap (DotP r) e-	Dot r e			-> return $ DotP r e-	Lit l			-> return $ LitP l-	HiddenArg r e		-> HiddenP r <$> T.mapM exprToPattern e-	RawApp r es		-> RawAppP r <$> mapM exprToPattern es-	OpApp r x es		-> OpAppP r x <$> mapM exprToPattern es-	_			->-          let Just pos = rStart $ getRange e in-          parseErrorAt pos $ "Not a valid pattern: " ++ show e--{---------------------------------------------------------------------------    Tests- --------------------------------------------------------------------------}---- | Test suite.-tests :: IO Bool-tests = runTests "Agda.Syntax.Parser.Parser"-  [ quickCheck' prop_splitOnDots-  ]-{-# 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 =---	trace "failing" $ -    	happyError_ 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:-+{-# OPTIONS_GHC -w #-}+{-# OPTIONS -fglasgow-exts -cpp #-}+{-# OPTIONS_GHC -fno-warn-incomplete-patterns+                -fno-warn-deprecated-flags #-}+{-# LANGUAGE BangPatterns #-}+{-| The parser is generated by Happy (<http://www.haskell.org/happy>).+-}+module Agda.Syntax.Parser.Parser (+      moduleParser+    , exprParser+    , tokensParser+    , tests+    ) where++import Control.Arrow+import Control.Monad+import Control.Monad.State+import Data.Char+import Data.List+import Data.Maybe+import qualified Data.Traversable as T++import Agda.Syntax.Position hiding (tests)+import Agda.Syntax.Parser.Monad+import Agda.Syntax.Parser.Lexer+import Agda.Syntax.Parser.Tokens+import Agda.Syntax.Concrete+import Agda.Syntax.Concrete.Name+import Agda.Syntax.Concrete.Pretty+import Agda.Syntax.Common+import Agda.Syntax.Fixity+import Agda.Syntax.Notation+import Agda.Syntax.Literal++import Agda.Utils.Monad+import Agda.Utils.QuickCheck+import Agda.Utils.TestHelpers+import qualified Data.Array as Happy_Data_Array+import qualified GHC.Exts as Happy_GHC_Exts++-- parser produced by Happy Version 1.18.6++newtype HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70 = HappyAbsSyn HappyAny+#if __GLASGOW_HASKELL__ >= 607+type HappyAny = Happy_GHC_Exts.Any+#else+type HappyAny = forall a . a+#endif+happyIn6 :: ([Token]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn6 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn6 #-}+happyOut6 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Token])+happyOut6 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut6 #-}+happyIn7 :: ([Token]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn7 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn7 #-}+happyOut7 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Token])+happyOut7 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut7 #-}+happyIn8 :: (Token) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn8 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn8 #-}+happyOut8 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Token)+happyOut8 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut8 #-}+happyIn9 :: (([Pragma], [Declaration])) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn9 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn9 #-}+happyOut9 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (([Pragma], [Declaration]))+happyOut9 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut9 #-}+happyIn10 :: t10 -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn10 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn10 #-}+happyOut10 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> t10+happyOut10 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut10 #-}+happyIn11 :: t11 -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn11 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn11 #-}+happyOut11 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> t11+happyOut11 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut11 #-}+happyIn12 :: t12 -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn12 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn12 #-}+happyOut12 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> t12+happyOut12 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut12 #-}+happyIn13 :: (()) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn13 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn13 #-}+happyOut13 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (())+happyOut13 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut13 #-}+happyIn14 :: (Integer) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn14 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn14 #-}+happyOut14 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Integer)+happyOut14 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut14 #-}+happyIn15 :: (Name) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn15 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn15 #-}+happyOut15 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Name)+happyOut15 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut15 #-}+happyIn16 :: ([Name]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn16 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn16 #-}+happyOut16 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Name])+happyOut16 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut16 #-}+happyIn17 :: (Range) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn17 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn17 #-}+happyOut17 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Range)+happyOut17 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut17 #-}+happyIn18 :: (Arg Name) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn18 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn18 #-}+happyOut18 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Arg Name)+happyOut18 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut18 #-}+happyIn19 :: ([Arg Name]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn19 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn19 #-}+happyOut19 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Arg Name])+happyOut19 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut19 #-}+happyIn20 :: ([Arg Name]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn20 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn20 #-}+happyOut20 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Arg Name])+happyOut20 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut20 #-}+happyIn21 :: (QName) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn21 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn21 #-}+happyOut21 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (QName)+happyOut21 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut21 #-}+happyIn22 :: (QName) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn22 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn22 #-}+happyOut22 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (QName)+happyOut22 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut22 #-}+happyIn23 :: (Name) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn23 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn23 #-}+happyOut23 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Name)+happyOut23 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut23 #-}+happyIn24 :: ([Name]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn24 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn24 #-}+happyOut24 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Name])+happyOut24 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut24 #-}+happyIn25 :: ([Name]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn25 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn25 #-}+happyOut25 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Name])+happyOut25 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut25 #-}+happyIn26 :: (Either [Name] [Expr]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn26 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn26 #-}+happyOut26 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Either [Name] [Expr])+happyOut26 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut26 #-}+happyIn27 :: ([String]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn27 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn27 #-}+happyOut27 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([String])+happyOut27 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut27 #-}+happyIn28 :: (QName) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn28 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn28 #-}+happyOut28 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (QName)+happyOut28 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut28 #-}+happyIn29 :: (Expr) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn29 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn29 #-}+happyOut29 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Expr)+happyOut29 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut29 #-}+happyIn30 :: t30 -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn30 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn30 #-}+happyOut30 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> t30+happyOut30 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut30 #-}+happyIn31 :: ([Expr]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn31 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn31 #-}+happyOut31 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Expr])+happyOut31 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut31 #-}+happyIn32 :: ([Expr]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn32 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn32 #-}+happyOut32 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Expr])+happyOut32 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut32 #-}+happyIn33 :: t33 -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn33 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn33 #-}+happyOut33 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> t33+happyOut33 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut33 #-}+happyIn34 :: ([Expr]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn34 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn34 #-}+happyOut34 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Expr])+happyOut34 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut34 #-}+happyIn35 :: t35 -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn35 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn35 #-}+happyOut35 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> t35+happyOut35 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut35 #-}+happyIn36 :: t36 -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn36 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn36 #-}+happyOut36 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> t36+happyOut36 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut36 #-}+happyIn37 :: t37 -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn37 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn37 #-}+happyOut37 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> t37+happyOut37 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut37 #-}+happyIn38 :: ([(Name, Expr)]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn38 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn38 #-}+happyOut38 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([(Name, Expr)])+happyOut38 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut38 #-}+happyIn39 :: ([(Name, Expr)]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn39 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn39 #-}+happyOut39 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([(Name, Expr)])+happyOut39 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut39 #-}+happyIn40 :: ((Name, Expr)) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn40 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn40 #-}+happyOut40 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ((Name, Expr))+happyOut40 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut40 #-}+happyIn41 :: t41 -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn41 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn41 #-}+happyOut41 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> t41+happyOut41 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut41 #-}+happyIn42 :: t42 -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn42 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn42 #-}+happyOut42 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> t42+happyOut42 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut42 #-}+happyIn43 :: ([TypedBindings]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn43 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn43 #-}+happyOut43 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([TypedBindings])+happyOut43 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut43 #-}+happyIn44 :: (TypedBindings) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn44 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn44 #-}+happyOut44 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (TypedBindings)+happyOut44 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut44 #-}+happyIn45 :: (TypedBinding) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn45 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn45 #-}+happyOut45 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (TypedBinding)+happyOut45 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut45 #-}+happyIn46 :: ([LamBinding]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn46 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn46 #-}+happyOut46 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([LamBinding])+happyOut46 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut46 #-}+happyIn47 :: (Either ([LamBinding], Hiding) [Expr]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn47 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn47 #-}+happyOut47 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Either ([LamBinding], Hiding) [Expr])+happyOut47 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut47 #-}+happyIn48 :: ([Either Hiding LamBinding]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn48 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn48 #-}+happyOut48 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Either Hiding LamBinding])+happyOut48 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut48 #-}+happyIn49 :: (Either [Either Hiding LamBinding] [Expr]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn49 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn49 #-}+happyOut49 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Either [Either Hiding LamBinding] [Expr])+happyOut49 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut49 #-}+happyIn50 :: ((LHS,RHS,WhereClause)) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn50 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn50 #-}+happyOut50 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ((LHS,RHS,WhereClause))+happyOut50 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut50 #-}+happyIn51 :: ((LHS,RHS,WhereClause)) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn51 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn51 #-}+happyOut51 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ((LHS,RHS,WhereClause))+happyOut51 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut51 #-}+happyIn52 :: ((LHS,RHS,WhereClause)) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn52 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn52 #-}+happyOut52 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ((LHS,RHS,WhereClause))+happyOut52 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut52 #-}+happyIn53 :: ([(LHS,RHS,WhereClause)]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn53 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn53 #-}+happyOut53 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([(LHS,RHS,WhereClause)])+happyOut53 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut53 #-}+happyIn54 :: ([LamBinding]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn54 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn54 #-}+happyOut54 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([LamBinding])+happyOut54 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut54 #-}+happyIn55 :: ([LamBinding]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn55 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn55 #-}+happyOut55 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([LamBinding])+happyOut55 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut55 #-}+happyIn56 :: ([LamBinding]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn56 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn56 #-}+happyOut56 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([LamBinding])+happyOut56 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut56 #-}+happyIn57 :: ([LamBinding]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn57 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn57 #-}+happyOut57 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([LamBinding])+happyOut57 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut57 #-}+happyIn58 :: (Either [LamBinding] [Expr]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn58 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn58 #-}+happyOut58 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Either [LamBinding] [Expr])+happyOut58 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut58 #-}+happyIn59 :: ((Maybe AsName, ImportDirective)) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn59 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn59 #-}+happyOut59 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ((Maybe AsName, ImportDirective))+happyOut59 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut59 #-}+happyIn60 :: (ImportDirective) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn60 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn60 #-}+happyOut60 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (ImportDirective)+happyOut60 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut60 #-}+happyIn61 :: (ImportDirective) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn61 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn61 #-}+happyOut61 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (ImportDirective)+happyOut61 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut61 #-}+happyIn62 :: (ImportDirective) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn62 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn62 #-}+happyOut62 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (ImportDirective)+happyOut62 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut62 #-}+happyIn63 :: ((UsingOrHiding , Range)) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn63 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn63 #-}+happyOut63 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ((UsingOrHiding , Range))+happyOut63 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut63 #-}+happyIn64 :: (([Renaming] , Range)) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn64 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn64 #-}+happyOut64 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (([Renaming] , Range))+happyOut64 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut64 #-}+happyIn65 :: ([Renaming]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn65 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn65 #-}+happyOut65 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Renaming])+happyOut65 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut65 #-}+happyIn66 :: (Renaming) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn66 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn66 #-}+happyOut66 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Renaming)+happyOut66 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut66 #-}+happyIn67 :: (ImportedName) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn67 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn67 #-}+happyOut67 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (ImportedName)+happyOut67 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut67 #-}+happyIn68 :: (ImportedName) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn68 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn68 #-}+happyOut68 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (ImportedName)+happyOut68 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut68 #-}+happyIn69 :: ([ImportedName]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn69 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn69 #-}+happyOut69 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([ImportedName])+happyOut69 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut69 #-}+happyIn70 :: t70 -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn70 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn70 #-}+happyOut70 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> t70+happyOut70 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut70 #-}+happyIn71 :: (LHS) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn71 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn71 #-}+happyOut71 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (LHS)+happyOut71 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut71 #-}+happyIn72 :: ([Pattern]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn72 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn72 #-}+happyOut72 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Pattern])+happyOut72 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut72 #-}+happyIn73 :: ([Expr]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn73 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn73 #-}+happyOut73 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Expr])+happyOut73 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut73 #-}+happyIn74 :: ([Expr]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn74 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn74 #-}+happyOut74 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Expr])+happyOut74 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut74 #-}+happyIn75 :: (WhereClause) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn75 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn75 #-}+happyOut75 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (WhereClause)+happyOut75 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut75 #-}+happyIn76 :: ([Declaration]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn76 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn76 #-}+happyOut76 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Declaration])+happyOut76 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut76 #-}+happyIn77 :: ([Declaration]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn77 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn77 #-}+happyOut77 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Declaration])+happyOut77 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut77 #-}+happyIn78 :: (Declaration) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn78 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn78 #-}+happyOut78 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Declaration)+happyOut78 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut78 #-}+happyIn79 :: ([Declaration]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn79 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn79 #-}+happyOut79 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Declaration])+happyOut79 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut79 #-}+happyIn80 :: ([Arg Declaration]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn80 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn80 #-}+happyOut80 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Arg Declaration])+happyOut80 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut80 #-}+happyIn81 :: (Declaration) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn81 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn81 #-}+happyOut81 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Declaration)+happyOut81 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut81 #-}+happyIn82 :: (RHS) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn82 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn82 #-}+happyOut82 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (RHS)+happyOut82 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut82 #-}+happyIn83 :: (Declaration) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn83 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn83 #-}+happyOut83 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Declaration)+happyOut83 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut83 #-}+happyIn84 :: (Declaration) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn84 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn84 #-}+happyOut84 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Declaration)+happyOut84 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut84 #-}+happyIn85 :: (Declaration) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn85 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn85 #-}+happyOut85 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Declaration)+happyOut85 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut85 #-}+happyIn86 :: (Declaration) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn86 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn86 #-}+happyOut86 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Declaration)+happyOut86 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut86 #-}+happyIn87 :: (Name) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn87 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn87 #-}+happyOut87 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Name)+happyOut87 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut87 #-}+happyIn88 :: (Declaration) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn88 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn88 #-}+happyOut88 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Declaration)+happyOut88 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut88 #-}+happyIn89 :: ([Declaration]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn89 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn89 #-}+happyOut89 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Declaration])+happyOut89 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut89 #-}+happyIn90 :: (Declaration) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn90 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn90 #-}+happyOut90 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Declaration)+happyOut90 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut90 #-}+happyIn91 :: (Declaration) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn91 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn91 #-}+happyOut91 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Declaration)+happyOut91 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut91 #-}+happyIn92 :: (Declaration) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn92 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn92 #-}+happyOut92 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Declaration)+happyOut92 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut92 #-}+happyIn93 :: (Declaration) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn93 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn93 #-}+happyOut93 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Declaration)+happyOut93 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut93 #-}+happyIn94 :: (Declaration) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn94 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn94 #-}+happyOut94 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Declaration)+happyOut94 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut94 #-}+happyIn95 :: (Declaration) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn95 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn95 #-}+happyOut95 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Declaration)+happyOut95 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut95 #-}+happyIn96 :: ([String]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn96 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn96 #-}+happyOut96 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([String])+happyOut96 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut96 #-}+happyIn97 :: ([HoleName]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn97 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn97 #-}+happyOut97 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([HoleName])+happyOut97 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut97 #-}+happyIn98 :: (HoleName) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn98 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn98 #-}+happyOut98 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (HoleName)+happyOut98 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut98 #-}+happyIn99 :: (String) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn99 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn99 #-}+happyOut99 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (String)+happyOut99 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut99 #-}+happyIn100 :: (Declaration) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn100 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn100 #-}+happyOut100 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Declaration)+happyOut100 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut100 #-}+happyIn101 :: ([Expr]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn101 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn101 #-}+happyOut101 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Expr])+happyOut101 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut101 #-}+happyIn102 :: ([TypedBindings] -> Parser ModuleApplication) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn102 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn102 #-}+happyOut102 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([TypedBindings] -> Parser ModuleApplication)+happyOut102 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut102 #-}+happyIn103 :: (Declaration) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn103 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn103 #-}+happyOut103 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Declaration)+happyOut103 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut103 #-}+happyIn104 :: (Declaration) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn104 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn104 #-}+happyOut104 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Declaration)+happyOut104 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut104 #-}+happyIn105 :: (Declaration) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn105 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn105 #-}+happyOut105 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Declaration)+happyOut105 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut105 #-}+happyIn106 :: ([Declaration]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn106 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn106 #-}+happyOut106 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Declaration])+happyOut106 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut106 #-}+happyIn107 :: (Declaration) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn107 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn107 #-}+happyOut107 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Declaration)+happyOut107 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut107 #-}+happyIn108 :: (Declaration) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn108 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn108 #-}+happyOut108 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Declaration)+happyOut108 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut108 #-}+happyIn109 :: (Pragma) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn109 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn109 #-}+happyOut109 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Pragma)+happyOut109 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut109 #-}+happyIn110 :: (Pragma) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn110 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn110 #-}+happyOut110 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Pragma)+happyOut110 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut110 #-}+happyIn111 :: (Pragma) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn111 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn111 #-}+happyOut111 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Pragma)+happyOut111 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut111 #-}+happyIn112 :: (Pragma) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn112 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn112 #-}+happyOut112 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Pragma)+happyOut112 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut112 #-}+happyIn113 :: (Pragma) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn113 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn113 #-}+happyOut113 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Pragma)+happyOut113 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut113 #-}+happyIn114 :: (Pragma) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn114 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn114 #-}+happyOut114 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Pragma)+happyOut114 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut114 #-}+happyIn115 :: (Pragma) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn115 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn115 #-}+happyOut115 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Pragma)+happyOut115 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut115 #-}+happyIn116 :: (Pragma) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn116 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn116 #-}+happyOut116 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Pragma)+happyOut116 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut116 #-}+happyIn117 :: (Pragma) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn117 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn117 #-}+happyOut117 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Pragma)+happyOut117 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut117 #-}+happyIn118 :: (Pragma) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn118 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn118 #-}+happyOut118 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Pragma)+happyOut118 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut118 #-}+happyIn119 :: (Pragma) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn119 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn119 #-}+happyOut119 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Pragma)+happyOut119 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut119 #-}+happyIn120 :: (Pragma) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn120 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn120 #-}+happyOut120 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Pragma)+happyOut120 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut120 #-}+happyIn121 :: (Pragma) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn121 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn121 #-}+happyOut121 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Pragma)+happyOut121 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut121 #-}+happyIn122 :: ([TypeSignature]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn122 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn122 #-}+happyOut122 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([TypeSignature])+happyOut122 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut122 #-}+happyIn123 :: ([TypeSignature]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn123 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn123 #-}+happyOut123 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([TypeSignature])+happyOut123 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut123 #-}+happyIn124 :: ([TypeSignature]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn124 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn124 #-}+happyOut124 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([TypeSignature])+happyOut124 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut124 #-}+happyIn125 :: ([TypeSignature]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn125 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn125 #-}+happyOut125 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([TypeSignature])+happyOut125 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut125 #-}+happyIn126 :: ([Arg TypeSignature]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn126 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn126 #-}+happyOut126 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Arg TypeSignature])+happyOut126 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut126 #-}+happyIn127 :: ([Arg TypeSignature]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn127 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn127 #-}+happyOut127 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Arg TypeSignature])+happyOut127 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut127 #-}+happyIn128 :: ([Constructor]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn128 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn128 #-}+happyOut128 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Constructor])+happyOut128 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut128 #-}+happyIn129 :: ((Maybe Name, [Declaration])) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn129 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn129 #-}+happyOut129 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ((Maybe Name, [Declaration]))+happyOut129 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut129 #-}+happyIn130 :: ([Declaration]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn130 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn130 #-}+happyOut130 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Declaration])+happyOut130 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut130 #-}+happyIn131 :: ([Declaration]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn131 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn131 #-}+happyOut131 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Declaration])+happyOut131 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut131 #-}+happyIn132 :: ([Declaration]) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyIn132 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn132 #-}+happyOut132 :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> ([Declaration])+happyOut132 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut132 #-}+happyInTok :: (Token) -> (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70)+happyInTok x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyInTok #-}+happyOutTok :: (HappyAbsSyn t10 t11 t12 t30 t33 t35 t36 t37 t41 t42 t70) -> (Token)+happyOutTok x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOutTok #-}+++happyActOffsets :: HappyAddr+happyActOffsets = HappyA# "\x00\x00\xd9\x05\x1f\x00\x00\x00\xb8\x02\x34\x05\x00\x00\x4d\x02\x4d\x02\x00\x00\x00\x00\x1f\x00\x00\x00\x58\x00\xc7\x03\xc7\x03\x59\x05\x3a\x05\x00\x00\x2a\x05\x00\x00\x00\x00\x00\x00\x00\x00\xfb\x00\x00\x00\x00\x00\xa8\x05\x81\x05\x35\x05\x00\x00\xff\x00\x2c\x05\x9a\x07\x00\x00\x00\x00\x66\x07\x2b\x05\x00\x00\x00\x00\x00\x00\x00\x00\xd0\x02\x73\x07\x00\x00\x00\x00\x3f\x07\xaa\x04\x90\x03\x77\x04\x00\x00\x00\x00\x00\x00\x24\x05\xe5\x00\x38\x05\x00\x00\x27\x05\xd4\x01\x25\x05\x00\x00\xe1\x00\x00\x00\x69\x01\x69\x01\x00\x00\x23\x05\x26\x05\x1c\x05\x00\x00\x00\x00\x00\x00\xa4\x01\x81\x05\x00\x00\x20\x05\x00\x00\x18\x07\x39\x01\x6c\x02\x20\x02\x00\x00\x89\x06\x50\x05\x58\x06\x00\x00\x4c\x07\x50\x04\x90\x03\x1d\x04\xb0\x06\xb0\x06\xb0\x06\x4e\x05\xf1\x06\x29\x05\x1f\x05\xf1\x06\x00\x00\xb0\x06\xb0\x06\xb0\x06\x11\x05\xf6\x03\x90\x03\x06\x05\x4a\x05\x03\x03\x00\x00\x60\x01\xb0\x06\xb0\x06\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x03\x29\x05\xb0\x06\x4c\x07\x03\x05\x00\x00\x00\x00\xf1\x06\x35\x00\x25\x07\xc7\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x35\x00\xfe\x06\x36\x02\x5d\x03\x00\x00\x00\x00\x00\x00\x00\x00\x36\x05\x00\x00\x02\x05\x01\x05\xff\x04\x71\x03\xee\x04\xf1\x06\x31\x05\xf1\x06\xec\x04\xe7\x04\x00\x00\x00\x00\xed\x04\x00\x00\x00\x00\xb0\x06\xb0\x06\xb0\x06\xb0\x06\xd2\x01\x22\x05\xeb\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\xdc\x04\xda\x04\x9f\x00\xc9\x04\xc9\x04\xc9\x04\xd7\x06\xd8\x04\xcc\x04\xcc\x04\xcc\x04\xd2\x04\xd2\x04\xd2\x04\xc4\x04\xc6\x04\xa7\x01\xc7\x0c\x29\x05\xbe\x04\xb8\x04\x00\x00\xbc\x04\xb0\x04\xb4\x04\xcf\xff\x00\x00\x00\x00\x00\x00\x00\x00\x29\x05\xa8\x04\x69\x01\xb1\x04\xa4\x04\x69\x01\x9c\x04\xca\x00\xac\x04\x00\x00\x73\x00\xe8\xff\xa7\x04\xa6\x04\xa5\x04\x00\x00\xb0\x06\xb0\x06\x00\x00\xb0\x06\xb0\x06\xca\x06\xa2\x04\xca\x06\x31\x06\xf8\x04\x00\x06\x00\x00\x00\x00\xa0\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd1\x04\x00\x00\x00\x00\xd1\x04\xd1\x04\x91\x04\x00\x00\x69\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x91\x00\xcf\xff\x64\x00\xcf\xff\xb0\x06\x00\x00\x00\x00\x00\x00\xb0\x06\xd1\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x75\x04\x86\x04\x00\x00\xd1\x04\x00\x00\x7e\x04\x7a\x04\x7c\x04\x74\x04\x74\x04\x74\x04\x74\x04\x74\x04\x74\x04\x74\x04\xcc\x00\xb5\x04\xa7\x01\xc5\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x6e\x00\x6e\x00\x00\x00\xce\x04\xaa\x03\xaf\x06\xaf\x06\xaf\x06\x6d\x04\x00\x00\x6d\x04\x00\x00\xed\xff\x00\x00\x03\x03\x00\x00\x00\x00\xdf\x00\xd1\x04\xae\x04\xd1\x04\xd1\x04\x00\x00\x00\x00\x00\x00\x70\x04\x00\x00\x36\x02\x00\x00\xa1\x04\x14\x00\x14\x00\x00\x00\x69\x01\x00\x00\x00\x00\x00\x00\x36\x02\x00\x00\x6b\x04\x6f\x04\x00\x00\x5f\x04\x6e\x04\x5e\x04\x60\x04\x69\x04\x8d\x04\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x02\x00\x00\x00\x00\x00\x00\xd1\x04\x00\x00\x00\x00\x59\x04\x4f\x04\x00\x00\x00\x00\xed\xff\x61\x04\x00\x00\x59\x00\x4d\x04\x4d\x04\x5b\x04\x00\x00\x59\x00\xaf\x06\x7f\x00\xac\x00\x9c\x00\x09\x00\xce\x04\x57\x04\x00\x00\x59\x00\x0e\x01\xc9\x01\xed\xff\xed\xff\x6e\x00\x00\x00\x00\x00\x00\x00\xeb\x00\x00\x00\x00\x00\x51\x04\x00\x00\x45\x04\xa7\x01\x6a\x04\xd1\x04\x39\x04\x00\x00\x20\x04\x20\x04\x20\x04\x1f\x04\x1a\x04\x38\x04\x00\x00\x32\x04\x16\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x04\x00\x00\x00\x00\x12\x04\x13\x04\x11\x04\x0f\x04\x0c\x04\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x04\x00\x00\x0a\x04\x00\x00\x0b\x04\x49\x01\x00\x00\x04\x04\x04\x04\x04\x04\x04\x04\x00\x00\xce\x04\xd1\x04\x00\x00\x02\x04\xd1\x04\x01\x04\xd1\x04\x01\x04\xd1\x04\x00\x04\xc7\x03\x06\x04\x00\x00\xf3\x03\xd1\x04\x00\x00\x00\x00\xed\xff\xd1\x04\x00\x00\x2f\x04\x00\x00\x00\x00\x00\x00\xe9\x03\xe9\x03\x27\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x03\x00\x00\x00\x00\x00\x00\x00\x00\xc7\x03\x3c\x01\x36\x02\x00\x00\x24\x04\x00\x00\x00\x00\x13\x00\x23\x04\x00\x00\x22\x04\x00\x00\x21\x02\x00\x00\x00\x00\xdd\x03\x49\x01\xd2\x03\x49\x01\xce\x04\xce\x04\xc2\x03\x00\x00\xcd\x03\x00\x00\x00\x00\x00\x00\xbc\x03\x00\x00\x00\x00\x00\x00\xb7\x03\x00\x00\x00\x00\x00\x00\xce\x04\xce\x04\xce\x04\xce\x04\x00\x00\x59\x00\x59\x00\xab\x03\xb5\x03\xa5\x03\x00\x00\xa5\x03\x00\x00\x00\x00\x2a\x03\x36\x02\x00\x00\x00\x00\x49\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x03\x00\x00\x00\x00\x00\x00\x00\x00\xac\x03\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00"#++happyGotoOffsets :: HappyAddr+happyGotoOffsets = HappyA# "\xbf\x03\xc0\x0c\x1a\x00\xe5\x03\xd8\x03\x00\x00\x00\x00\x01\x03\xc2\x02\x00\x00\x00\x00\x2e\x00\x00\x00\x81\x02\x68\x02\x1c\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\x03\xa8\x0c\x00\x00\x00\x00\x8b\x03\x5b\x03\xf4\x00\x00\x00\x00\x00\x17\x05\xcb\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x05\x00\x00\x00\x00\x1d\x02\x7d\x08\x19\x08\x64\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x03\xba\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x05\x90\x0c\x00\x00\x00\x00\x00\x00\x70\x05\x00\x00\x0d\x01\x22\x00\x00\x00\x51\x0a\xb3\x08\xdb\x07\x00\x00\x40\x05\x4b\x08\xfa\x07\x32\x08\x3a\x0a\x23\x0a\x0c\x0a\x00\x00\xb8\x07\x78\x0c\x00\x00\x76\x06\x00\x00\xf5\x09\xde\x09\xc7\x09\x00\x00\x60\x0c\x68\x0a\xf3\x00\x00\x00\x42\x01\x00\x00\x00\x00\xb0\x09\x99\x09\x00\x00\x00\x00\x00\x00\x00\x00\x48\x0c\x30\x0c\x65\x03\x0f\x05\xb9\x03\x00\x00\x00\x00\x1e\x06\x44\x0a\xdc\x00\xae\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\xc6\x07\x8d\x00\x7b\x08\x68\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x92\x03\x00\x00\x00\x00\x00\x00\x00\x00\x18\x03\xaf\x03\xc6\x05\x00\x00\x6e\x05\x00\x00\x86\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x04\x82\x09\x6b\x09\x54\x09\x00\x00\x5c\x03\x4d\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\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\x03\x1c\x03\xf4\x02\x43\x01\x57\x03\x4a\x03\x3f\x03\xda\x00\xc7\x02\x2f\x03\x24\x03\x22\x03\xac\x02\x9a\x02\x92\x02\xae\x02\x70\x02\xe8\x04\x00\x00\x18\x0c\x00\x00\x00\x00\x00\x00\x00\x00\xee\x00\x00\x00\x9d\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x00\x9b\x02\x00\x00\x00\x00\x94\x02\x00\x00\x00\x00\x00\x00\x00\x00\x8e\x02\x75\x02\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x09\x26\x09\x00\x00\x0f\x09\xf8\x08\xff\x02\x00\x00\x69\x02\xe1\x08\x9c\x08\xca\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe8\x0b\x00\x00\x00\x00\xd0\x0b\xb8\x0b\x00\x00\x00\x00\x6e\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x02\x00\x00\x59\x02\x58\x04\x00\x00\x00\x00\x00\x00\xfe\x03\xa0\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x00\x00\x88\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x44\x02\x3d\x02\x28\x02\x19\x02\x17\x02\xf6\x01\xf3\x01\x00\x00\xba\x01\xb2\x01\xaa\x02\x00\x00\x00\x00\x00\x00\xd9\x01\x00\x00\x95\x01\x6e\x01\x00\x00\x16\x00\x97\x04\x3d\x04\xe3\x03\xb0\x03\xf0\x01\x00\x00\x1c\x00\x00\x00\xfd\xff\x00\x00\xad\x01\x00\x00\x00\x00\xaf\x01\x70\x0b\xb3\x01\x58\x0b\x40\x0b\x00\x00\x00\x00\x00\x00\x2d\x03\x00\x00\xba\x07\x00\x00\xce\x00\xc0\x00\xf9\xff\x00\x00\xd1\x01\x00\x00\x00\x00\x00\x00\x9f\x06\x00\x00\x00\x00\x00\x00\x00\x00\xe0\x01\x00\x00\xd7\x01\x00\x00\x00\x00\x00\x00\xc6\x01\x00\x00\x00\x00\x00\x00\x6c\x00\x00\x00\x00\x00\x00\x00\x28\x0b\x00\x00\x00\x00\x48\x01\xb6\x01\x00\x00\x00\x00\x64\x03\x00\x00\x00\x00\x9e\x03\xb1\x01\x6d\x03\x00\x00\x00\x00\x87\x03\x5a\x02\x00\x00\x00\x00\x00\x00\x00\x00\x34\x04\x00\x00\x00\x00\x80\x03\x00\x00\xb1\x01\x2c\x03\x89\x02\x08\x01\x00\x00\x00\x00\x00\x00\xfd\x02\x00\x00\x00\x00\x00\x00\x00\x00\x76\x01\x47\x01\x3b\x01\x10\x0b\x00\x00\x00\x00\x7e\x01\x79\x01\x6d\x01\x00\x00\x67\x01\x00\x00\x00\x00\x00\x00\x5f\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\x58\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x01\x00\x00\x14\x01\x00\x00\x00\x00\x4e\x01\x00\x00\x19\x03\xa6\x02\x98\x02\x66\x02\x00\x00\x28\x00\xf8\x0a\x00\x00\xd9\x00\xe0\x0a\x7d\x01\xc8\x0a\x73\x01\xb0\x0a\xcd\x01\x67\x00\x00\x00\x00\x00\x32\x00\x98\x0a\x00\x00\x00\x00\xbf\x00\x80\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2d\x01\x1a\x01\xc9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x85\x00\x75\x06\x00\x00\x00\x00\x00\x00\x00\x00\xfe\xff\x00\x00\x00\x00\x00\x00\x00\x00\xfc\xff\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xa8\x00\xf0\x03\xbd\x03\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xeb\xff\x00\x00\x00\x00\x00\x00\x8a\x03\x41\x03\x35\x03\x04\x00\x00\x00\x1e\x02\xd3\x01\x31\x00\xb1\xff\x28\x01\x00\x00\x12\x01\x00\x00\x00\x00\x68\x0a\x1d\x06\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x95\x00\x00\x00\x00\x00\x00\x00"#++happyDefActions :: HappyAddr+happyDefActions = HappyA# "\xfa\xff\x00\x00\x00\x00\x00\x00\xfc\xff\x00\x00\xae\xff\x00\x00\x00\x00\xad\xff\xbb\xfe\x00\x00\xb6\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x8d\xff\x6e\xff\x00\x00\x7f\xff\x7e\xff\x7c\xff\x7b\xff\x00\x00\x5b\xff\x5a\xff\x75\xff\x00\x00\x00\x00\x53\xff\x51\xff\x00\x00\x00\x00\x6a\xff\x69\xff\x00\x00\x00\x00\x68\xff\x67\xff\x66\xff\x65\xff\x00\x00\x00\x00\x6b\xff\x6c\xff\x00\x00\x00\x00\x00\x00\x00\x00\xa5\xff\x8e\xff\x6d\xff\x00\x00\x8d\xff\x00\x00\x87\xff\x00\x00\x86\xff\x00\x00\x6f\xff\x8d\xff\x60\xff\x00\x00\x00\x00\xa2\xff\x00\x00\x00\x00\x00\x00\x61\xff\x8b\xff\x26\xff\x3a\xff\x00\x00\x77\xff\x00\x00\x45\xff\x42\xff\x3b\xff\x00\x00\x00\x00\x8a\xff\x00\x00\x00\x00\x00\x00\x5e\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\xff\x00\x00\x00\x00\x2c\xff\x27\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\xff\x00\x00\x00\x00\x52\xff\x00\x00\x00\x00\x00\x00\x54\xff\x82\xff\x7a\xff\x72\xff\x00\x00\x00\x00\x00\x00\x00\x00\x85\xff\x8d\xff\x8c\xff\x28\xff\x15\xff\xc4\xfe\x00\x00\xac\xff\xba\xfe\xb9\xfe\xfb\xff\xf9\xff\xf8\xff\xf7\xff\xf6\xff\xf5\xff\xf4\xff\xf3\xff\xf2\xff\xf1\xff\xf0\xff\xef\xff\xee\xff\xed\xff\xec\xff\xeb\xff\xea\xff\xe9\xff\xe8\xff\xe7\xff\xe6\xff\xe5\xff\xe4\xff\xe3\xff\xe2\xff\xe1\xff\xe0\xff\xdf\xff\xde\xff\xdd\xff\xdc\xff\xdb\xff\xda\xff\xd9\xff\xd2\xff\xd1\xff\xd8\xff\xd7\xff\xd6\xff\xd5\xff\xd4\xff\xd3\xff\xd0\xff\xcf\xff\xce\xff\xcd\xff\xcc\xff\xcb\xff\xca\xff\xc9\xff\xc8\xff\xc7\xff\xc6\xff\xc5\xff\xc4\xff\xc3\xff\xc2\xff\xc1\xff\xc0\xff\xbf\xff\xbe\xff\xbd\xff\xbc\xff\xbb\xff\xba\xff\xb9\xff\xb8\xff\xb7\xff\xb6\xff\xb5\xff\xb4\xff\xb3\xff\xb2\xff\xb1\xff\xb0\xff\xaf\xff\x15\xff\xc4\xfe\x15\xff\x00\x00\xbe\xfe\x1d\xff\x1b\xff\x19\xff\x16\xff\x17\xff\x00\x00\x00\x00\x00\x00\x15\xff\x00\x00\x28\xff\x00\x00\x28\xff\x00\x00\x85\xff\x5f\xff\x7d\xff\x00\x00\x80\xff\x86\xff\x75\xff\x00\x00\x00\x00\x00\x00\x8d\xff\x00\xff\xe1\xfe\x8d\xfe\xfb\xfe\xf9\xfe\xf8\xfe\xf7\xfe\xf6\xfe\xf5\xfe\xf4\xfe\xfa\xfe\xf3\xfe\xf2\xfe\xf1\xfe\xf0\xfe\xef\xfe\xe9\xfe\xee\xfe\xec\xfe\xed\xfe\xeb\xfe\xea\xfe\xb7\xfe\xb5\xfe\xb4\xfe\xb2\xfe\xb3\xfe\xb1\xfe\xb0\xfe\xaf\xfe\xac\xfe\xae\xfe\xad\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\xff\x57\xff\x59\xff\x87\xff\x00\x00\x2e\xff\x2f\xff\x81\xff\x2d\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x35\xff\x00\x00\x30\xff\x00\x00\x00\x00\x38\xff\x37\xff\x39\xff\x25\xff\x00\x00\x00\x00\x24\xff\x00\x00\x00\x00\x41\xff\x3d\xff\x42\xff\x00\x00\x00\x00\x00\x00\x46\xff\x79\xff\x3c\xff\x4a\xff\x62\xff\xa1\xff\x49\xff\x64\xff\x00\x00\x48\xff\x71\xff\x00\x00\x00\x00\x00\x00\x47\xff\x00\x00\x3f\xff\x3e\xff\x40\xff\x44\xff\x43\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa9\xff\x78\xff\xa8\xff\x00\x00\x00\x00\x50\xff\x4e\xff\x4f\xff\x4d\xff\x4b\xff\x4c\xff\x74\xff\x22\xff\x23\xff\x00\x00\x00\x00\x5d\xff\x00\x00\x76\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\xff\x00\xff\x00\x00\x00\x00\xd1\xfe\xd2\xfe\xd3\xfe\x00\x00\xa6\xff\x00\x00\x00\x00\xd4\xfe\x00\x00\x28\xff\x28\xff\x28\xff\x28\xff\x00\x00\xcf\xfe\x00\x00\xd0\xfe\x00\x00\x91\xfe\x00\x00\xaa\xff\xab\xff\xfe\xfe\x00\x00\x02\xff\x00\x00\x00\x00\x84\xff\xab\xfe\x2a\xff\x00\x00\x29\xff\x15\xff\x1a\xff\xa7\xff\x00\x00\x0a\xff\x18\xff\x00\x00\xc6\xfe\xc3\xfe\xbd\xfe\x15\xff\x0c\xff\x08\xff\x00\x00\x09\xff\x00\x00\x00\x00\x00\x00\x00\x00\x10\xff\x00\x00\xa7\xff\x1c\xff\x8f\xfe\xb8\xfe\x00\x00\xe6\xfe\xff\xfe\x06\xff\x00\x00\xe2\xfe\xe3\xfe\x00\x00\x00\x00\x8e\xfe\x9f\xff\x9d\xff\x00\x00\x9b\xfe\x00\x00\x00\x00\xa3\xff\x00\x00\x9e\xfe\x00\x00\x28\xff\x00\x00\x00\x00\x00\x00\x00\x00\x9b\xff\x00\x00\x98\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\xff\xd7\xfe\xd6\xfe\xd5\xfe\x00\x00\xcb\xfe\xc9\xfe\x00\x00\xc7\xfe\x04\xff\x73\xff\x02\xff\x00\x00\x00\x00\x83\xff\x85\xff\x85\xff\x85\xff\x00\x00\x85\xff\x00\x00\xa1\xfe\x00\x00\x00\x00\x55\xff\x56\xff\x5c\xff\x36\xff\x35\xff\x34\xff\x33\xff\x31\xff\x32\xff\x20\xff\x21\xff\x1e\xff\x1f\xff\x63\xff\x70\xff\x00\x00\xa2\xfe\xa3\xfe\x00\x00\x85\xff\x00\x00\x00\x00\x00\x00\xa4\xfe\xe7\xfe\x05\xff\x03\xff\x00\x00\xca\xfe\x00\x00\x89\xff\x00\x00\x00\x00\xa0\xff\x00\x00\x00\x00\x00\x00\x00\x00\x9a\xfe\x00\x00\x00\x00\x9c\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\xfe\x00\x00\x00\x00\xa4\xff\x9d\xfe\x00\x00\x00\x00\x9e\xff\x00\x00\xfd\xfe\x01\xff\x90\xfe\x00\x00\x00\x00\xa7\xff\x12\xff\x0e\xff\x13\xff\x0b\xff\x14\xff\x00\x00\xc5\xfe\x07\xff\x11\xff\x0f\xff\x0d\xff\x00\x00\xe5\xfe\x9c\xfe\xe8\xfe\x9f\xfe\x00\x00\xc4\xfe\x15\xff\xbc\xfe\xdc\xfe\x96\xfe\xde\xfe\x00\x00\x00\x00\xdd\xfe\xd9\xfe\xda\xfe\x00\x00\xe4\xfe\x99\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x99\xff\x97\xff\xce\xfe\xcd\xfe\x00\x00\xa5\xfe\xa6\xfe\xa8\xfe\x00\x00\xa9\xfe\xaa\xfe\xa7\xfe\x00\x00\xcc\xfe\x98\xff\x9a\xff\x93\xff\x95\xff\x8f\xff\x91\xff\x95\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x97\xfe\x00\x00\xc0\xfe\xc1\xfe\x00\x00\x15\xff\xfc\xfe\xbf\xfe\x00\x00\xe0\xfe\xdf\xfe\xdb\xfe\xd8\xfe\x92\xfe\x94\xfe\x00\x00\x92\xff\x90\xff\x96\xff\x94\xff\x00\x00\xc8\xfe\x00\x00\xc2\xfe\x93\xfe"#++happyCheck :: HappyAddr+happyCheck = HappyA# "\xff\xff\x05\x00\x09\x00\x05\x00\x35\x00\x09\x00\x09\x00\x09\x00\x0a\x00\x0c\x00\x0d\x00\x0f\x00\x03\x00\x09\x00\x0b\x00\x40\x00\x0c\x00\x42\x00\x0e\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x34\x00\x03\x00\x04\x00\x09\x00\x33\x00\x09\x00\x0c\x00\x0f\x00\x0e\x00\x09\x00\x0a\x00\x08\x00\x09\x00\x09\x00\x42\x00\x09\x00\x7b\x00\x45\x00\x0f\x00\x0f\x00\x10\x00\x09\x00\x04\x00\x11\x00\x0c\x00\x48\x00\x0e\x00\x3e\x00\x3f\x00\x40\x00\x09\x00\x09\x00\x0a\x00\x41\x00\x35\x00\x0a\x00\x0b\x00\x0c\x00\x46\x00\x0e\x00\x48\x00\x47\x00\x49\x00\x4b\x00\x5d\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\x3e\x00\x44\x00\x40\x00\x00\x00\x5e\x00\x48\x00\x48\x00\x61\x00\x62\x00\x63\x00\x4a\x00\x09\x00\x66\x00\x47\x00\x68\x00\x46\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x09\x00\x05\x00\x4a\x00\x75\x00\x77\x00\x09\x00\x0f\x00\x10\x00\x5e\x00\x47\x00\x7e\x00\x0f\x00\x62\x00\x48\x00\x64\x00\x65\x00\x60\x00\x67\x00\x03\x00\x69\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x5e\x00\x34\x00\x09\x00\x79\x00\x62\x00\x75\x00\x64\x00\x65\x00\x0f\x00\x67\x00\x09\x00\x69\x00\x09\x00\x35\x00\x05\x00\x06\x00\x0f\x00\x44\x00\x45\x00\x03\x00\x48\x00\x49\x00\x1d\x00\x1e\x00\x1f\x00\x37\x00\x42\x00\x34\x00\x09\x00\x5d\x00\x1d\x00\x1e\x00\x1f\x00\x41\x00\x0f\x00\x03\x00\x21\x00\x22\x00\x46\x00\x0b\x00\x48\x00\x36\x00\x48\x00\x4b\x00\x45\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x0b\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x35\x00\x60\x00\x09\x00\x09\x00\x5e\x00\x0c\x00\x0d\x00\x61\x00\x62\x00\x63\x00\x07\x00\x35\x00\x66\x00\x42\x00\x68\x00\x07\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x09\x00\x35\x00\x03\x00\x09\x00\x5f\x00\x09\x00\x0f\x00\x48\x00\x49\x00\x0f\x00\x7e\x00\x0f\x00\x5f\x00\x7c\x00\x0f\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x09\x00\x1e\x00\x1d\x00\x1e\x00\x1f\x00\x09\x00\x09\x00\x3e\x00\x35\x00\x40\x00\x35\x00\x3d\x00\x0f\x00\x3b\x00\x3c\x00\x3d\x00\x3b\x00\x49\x00\x3b\x00\x3c\x00\x3d\x00\x42\x00\x48\x00\x20\x00\x21\x00\x22\x00\x09\x00\x1e\x00\x20\x00\x21\x00\x22\x00\x09\x00\x36\x00\x41\x00\x11\x00\x12\x00\x36\x00\x3b\x00\x46\x00\x11\x00\x48\x00\x3b\x00\x36\x00\x4b\x00\x09\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x3d\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x32\x00\x33\x00\x48\x00\x39\x00\x5e\x00\x09\x00\x3c\x00\x61\x00\x62\x00\x63\x00\x5f\x00\x3d\x00\x66\x00\x3f\x00\x68\x00\x41\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x09\x00\x09\x00\x3f\x00\x12\x00\x41\x00\x09\x00\x0f\x00\x0f\x00\x10\x00\x7b\x00\x7e\x00\x0f\x00\x1b\x00\x1c\x00\x0b\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x5d\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x32\x00\x33\x00\x15\x00\x5a\x00\x33\x00\x37\x00\x5d\x00\x39\x00\x37\x00\x38\x00\x16\x00\x3d\x00\x09\x00\x3f\x00\x3d\x00\x41\x00\x3f\x00\x15\x00\x41\x00\x43\x00\x11\x00\x12\x00\x48\x00\x15\x00\x41\x00\x48\x00\x49\x00\x74\x00\x4b\x00\x46\x00\x40\x00\x48\x00\x42\x00\x7a\x00\x4b\x00\x15\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x15\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x74\x00\x3d\x00\x09\x00\x3f\x00\x5e\x00\x41\x00\x7a\x00\x61\x00\x62\x00\x63\x00\x11\x00\x12\x00\x66\x00\x40\x00\x68\x00\x42\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x09\x00\x09\x00\x42\x00\x12\x00\x09\x00\x09\x00\x0f\x00\x0f\x00\x10\x00\x09\x00\x7e\x00\x0f\x00\x1b\x00\x1c\x00\x7c\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x07\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x32\x00\x33\x00\x05\x00\x06\x00\x33\x00\x37\x00\x0b\x00\x39\x00\x37\x00\x38\x00\x09\x00\x3d\x00\x09\x00\x3f\x00\x3d\x00\x41\x00\x3f\x00\x74\x00\x41\x00\x09\x00\x11\x00\x12\x00\x48\x00\x7a\x00\x41\x00\x48\x00\x49\x00\x74\x00\x4b\x00\x46\x00\x45\x00\x48\x00\x43\x00\x7a\x00\x4b\x00\x09\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x44\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x35\x00\x3f\x00\x16\x00\x41\x00\x5e\x00\x16\x00\x3b\x00\x61\x00\x62\x00\x63\x00\x48\x00\x3e\x00\x66\x00\x40\x00\x68\x00\x42\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x00\x00\x01\x00\x05\x00\x06\x00\x09\x00\x09\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0f\x00\x10\x00\x16\x00\x11\x00\x16\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\x16\x00\x1e\x00\x0a\x00\x0b\x00\x0c\x00\x26\x00\x0e\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x7c\x00\x7d\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x33\x00\x34\x00\x31\x00\x16\x00\x33\x00\x08\x00\x09\x00\x37\x00\x37\x00\x38\x00\x16\x00\x3a\x00\x0f\x00\x3d\x00\x3d\x00\x3f\x00\x3f\x00\x41\x00\x41\x00\x09\x00\x0b\x00\x44\x00\x0b\x00\x46\x00\x48\x00\x48\x00\x49\x00\x11\x00\x4b\x00\x00\x00\x01\x00\x09\x00\x0a\x00\x09\x00\x09\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0f\x00\x10\x00\x0b\x00\x11\x00\x06\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x26\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x09\x00\x1e\x00\x32\x00\x33\x00\x34\x00\x26\x00\x0f\x00\x10\x00\x09\x00\x2a\x00\x06\x00\x0c\x00\x0d\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x33\x00\x34\x00\x31\x00\x0b\x00\x33\x00\x09\x00\x0a\x00\x37\x00\x37\x00\x38\x00\x0b\x00\x3a\x00\x0b\x00\x3d\x00\x3d\x00\x3f\x00\x3f\x00\x41\x00\x41\x00\x09\x00\x0a\x00\x44\x00\x42\x00\x46\x00\x48\x00\x48\x00\x49\x00\x09\x00\x4b\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\x01\x00\x5b\x00\x5c\x00\x5d\x00\x09\x00\x06\x00\x07\x00\x08\x00\x09\x00\x3d\x00\x7c\x00\x3f\x00\x11\x00\x41\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x7c\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x5e\x00\x1e\x00\x09\x00\x0a\x00\x62\x00\x26\x00\x64\x00\x65\x00\x7c\x00\x2a\x00\x08\x00\x01\x00\x08\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x33\x00\x34\x00\x31\x00\x09\x00\x33\x00\x08\x00\x0c\x00\x0d\x00\x37\x00\x38\x00\x12\x00\x3a\x00\x09\x00\x78\x00\x3d\x00\x0c\x00\x3f\x00\x0e\x00\x41\x00\x1b\x00\x1c\x00\x1d\x00\x09\x00\x46\x00\x09\x00\x48\x00\x49\x00\x0c\x00\x4b\x00\x0e\x00\x38\x00\x39\x00\x3a\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x5c\x00\x5d\x00\x31\x00\x32\x00\x33\x00\x01\x00\x5e\x00\x09\x00\x37\x00\x38\x00\x62\x00\x3a\x00\x64\x00\x65\x00\x3d\x00\x74\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x09\x00\x09\x00\x12\x00\x0c\x00\x0d\x00\x48\x00\x49\x00\x0f\x00\x4b\x00\x09\x00\x0a\x00\x1b\x00\x1c\x00\x1d\x00\x0a\x00\x0b\x00\x0c\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x05\x00\x06\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x05\x00\x06\x00\x31\x00\x32\x00\x33\x00\x01\x00\x76\x00\x09\x00\x37\x00\x38\x00\x0c\x00\x3a\x00\x0e\x00\x4c\x00\x3d\x00\x15\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x44\x00\x09\x00\x12\x00\x05\x00\x06\x00\x48\x00\x49\x00\x0f\x00\x4b\x00\x7c\x00\x7d\x00\x1b\x00\x1c\x00\x1d\x00\x05\x00\x06\x00\x25\x00\x26\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x09\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x00\x00\x01\x00\x11\x00\x32\x00\x33\x00\x01\x00\x0b\x00\x09\x00\x37\x00\x38\x00\x0c\x00\x3a\x00\x0e\x00\x3a\x00\x3d\x00\x15\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x0b\x00\x09\x00\x12\x00\x26\x00\x7c\x00\x48\x00\x49\x00\x02\x00\x4b\x00\x32\x00\x33\x00\x1b\x00\x1c\x00\x1d\x00\x37\x00\x32\x00\x33\x00\x34\x00\x3b\x00\x01\x00\x3d\x00\x43\x00\x3f\x00\x3e\x00\x41\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x48\x00\x48\x00\x11\x00\x32\x00\x33\x00\x01\x00\x43\x00\x09\x00\x37\x00\x38\x00\x0c\x00\x3a\x00\x0e\x00\x48\x00\x3d\x00\x43\x00\x3f\x00\x47\x00\x41\x00\x42\x00\x39\x00\x09\x00\x12\x00\x26\x00\x48\x00\x48\x00\x49\x00\x0f\x00\x4b\x00\x48\x00\x49\x00\x1b\x00\x1c\x00\x1d\x00\x42\x00\x32\x00\x33\x00\x34\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x01\x00\x42\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x03\x00\x03\x00\x03\x00\x32\x00\x33\x00\x2c\x00\x2d\x00\x2e\x00\x37\x00\x38\x00\x12\x00\x3a\x00\x48\x00\x03\x00\x3d\x00\x3e\x00\x3f\x00\x0f\x00\x41\x00\x1b\x00\x1c\x00\x1d\x00\x48\x00\x36\x00\x09\x00\x48\x00\x49\x00\x0c\x00\x4b\x00\x0e\x00\x43\x00\x43\x00\x43\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x48\x00\x42\x00\x11\x00\x32\x00\x33\x00\x01\x00\x48\x00\x47\x00\x37\x00\x38\x00\x47\x00\x3a\x00\x47\x00\x47\x00\x3d\x00\x47\x00\x3f\x00\x4a\x00\x41\x00\x42\x00\x4a\x00\x09\x00\x12\x00\x26\x00\x4a\x00\x48\x00\x49\x00\x0f\x00\x4b\x00\x4a\x00\x4a\x00\x1b\x00\x1c\x00\x1d\x00\x04\x00\x32\x00\x33\x00\x34\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x01\x00\x47\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x47\x00\x47\x00\x3c\x00\x32\x00\x33\x00\x2c\x00\x2d\x00\x2e\x00\x37\x00\x38\x00\x12\x00\x3a\x00\x3a\x00\x35\x00\x3d\x00\x3e\x00\x3f\x00\x35\x00\x41\x00\x1b\x00\x1c\x00\x1d\x00\x48\x00\x35\x00\x48\x00\x48\x00\x49\x00\x0d\x00\x4b\x00\x43\x00\x34\x00\x3e\x00\x34\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x48\x00\x48\x00\x11\x00\x32\x00\x33\x00\x01\x00\x3e\x00\x3e\x00\x37\x00\x38\x00\x0f\x00\x3a\x00\x04\x00\x43\x00\x3d\x00\x48\x00\x3f\x00\x42\x00\x41\x00\x42\x00\x05\x00\x09\x00\x12\x00\x26\x00\x4a\x00\x48\x00\x49\x00\x0f\x00\x4b\x00\x47\x00\x4a\x00\x1b\x00\x1c\x00\x1d\x00\x4a\x00\x32\x00\x33\x00\x34\x00\x1a\x00\x1b\x00\x48\x00\x1d\x00\x1e\x00\x1f\x00\x01\x00\x42\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x39\x00\x3e\x00\x39\x00\x32\x00\x33\x00\x39\x00\x39\x00\x39\x00\x37\x00\x38\x00\x12\x00\x3a\x00\x39\x00\x42\x00\x3d\x00\x3e\x00\x3f\x00\x42\x00\x41\x00\x1b\x00\x1c\x00\x1d\x00\x3e\x00\x34\x00\x09\x00\x48\x00\x49\x00\x36\x00\x4b\x00\x42\x00\x0f\x00\x48\x00\x01\x00\x42\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x32\x00\x33\x00\x3c\x00\x32\x00\x33\x00\x1d\x00\x1e\x00\x1f\x00\x37\x00\x38\x00\x12\x00\x3a\x00\x48\x00\x3f\x00\x3d\x00\x41\x00\x3f\x00\x48\x00\x41\x00\x1b\x00\x1c\x00\x43\x00\x48\x00\x4b\x00\x09\x00\x48\x00\x49\x00\x43\x00\x4b\x00\x43\x00\x0f\x00\x43\x00\x09\x00\x36\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x05\x00\x11\x00\x3c\x00\x01\x00\x33\x00\x1d\x00\x1e\x00\x1f\x00\x37\x00\x38\x00\x4a\x00\x3a\x00\x47\x00\x03\x00\x3d\x00\x48\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x12\x00\x3d\x00\x26\x00\x3d\x00\x3d\x00\x48\x00\x49\x00\x0c\x00\x4b\x00\x1b\x00\x1c\x00\x1d\x00\x30\x00\x31\x00\x09\x00\x33\x00\x34\x00\x02\x00\x4a\x00\x48\x00\x0f\x00\x02\x00\x01\x00\x41\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x39\x00\x39\x00\x3e\x00\x32\x00\x33\x00\x1d\x00\x1e\x00\x1f\x00\x37\x00\x38\x00\x12\x00\x3a\x00\x3e\x00\x42\x00\x3d\x00\x42\x00\x3f\x00\x42\x00\x41\x00\x1b\x00\x1c\x00\x35\x00\x39\x00\x43\x00\x4c\x00\x48\x00\x49\x00\x48\x00\x4b\x00\x3b\x00\x4c\x00\x09\x00\x1f\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x11\x00\x4c\x00\x11\x00\x01\x00\x33\x00\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\xff\xff\x3a\x00\xff\xff\xff\xff\x3d\x00\xff\xff\x3f\x00\x40\x00\x41\x00\x42\x00\x12\x00\x26\x00\xff\xff\x26\x00\xff\xff\x48\x00\x49\x00\x2a\x00\x4b\x00\x1b\x00\x1c\x00\x1d\x00\xff\xff\x32\x00\x33\x00\x34\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\xff\xff\xff\xff\xff\xff\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\x12\x00\x3a\x00\xff\xff\xff\xff\x3d\x00\xff\xff\x3f\x00\xff\xff\x41\x00\x1b\x00\x1c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\xff\xff\x4b\x00\xff\xff\xff\xff\x09\x00\xff\xff\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x11\x00\xff\xff\x11\x00\x01\x00\x33\x00\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\xff\xff\x3f\x00\xff\xff\x41\x00\xff\xff\x12\x00\x26\x00\xff\xff\x26\x00\xff\xff\x48\x00\x49\x00\x2a\x00\x4b\x00\x1b\x00\x1c\x00\x1d\x00\xff\xff\x32\x00\x33\x00\x34\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\xff\xff\xff\xff\xff\xff\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\x12\x00\x3a\x00\xff\xff\xff\xff\x3d\x00\xff\xff\x3f\x00\xff\xff\x41\x00\x1b\x00\x1c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\xff\xff\x4b\x00\xff\xff\xff\xff\x09\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x11\x00\xff\xff\xff\xff\x01\x00\x33\x00\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\xff\xff\x3a\x00\xff\xff\xff\xff\x3d\x00\xff\xff\x3f\x00\xff\xff\x41\x00\x42\x00\x12\x00\x26\x00\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\xff\xff\x4b\x00\x1b\x00\x1c\x00\xff\xff\xff\xff\x32\x00\x33\x00\x34\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x01\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\x12\x00\x3a\x00\xff\xff\xff\xff\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x1b\x00\x1c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\xff\xff\x4b\x00\xff\xff\xff\xff\x09\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x11\x00\xff\xff\xff\xff\x01\x00\x33\x00\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\xff\xff\x3a\x00\xff\xff\xff\xff\x3d\x00\xff\xff\x3f\x00\xff\xff\x41\x00\x42\x00\x12\x00\x26\x00\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\xff\xff\x4b\x00\x1b\x00\x1c\x00\xff\xff\x31\x00\xff\xff\x33\x00\x34\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x01\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\x12\x00\x3a\x00\xff\xff\xff\xff\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x1b\x00\x1c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\xff\xff\x4b\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\xff\xff\xff\xff\x32\x00\x33\x00\x33\x00\xff\xff\xff\xff\x37\x00\x37\x00\x38\x00\x12\x00\x3a\x00\xff\xff\x3d\x00\x3d\x00\x3f\x00\x3f\x00\x41\x00\x41\x00\x1b\x00\x1c\x00\xff\xff\xff\xff\xff\xff\x48\x00\x48\x00\x49\x00\xff\xff\x4b\x00\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\x37\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\xff\xff\x3d\x00\xff\xff\x3f\x00\x33\x00\x41\x00\xff\xff\xff\xff\x37\x00\x38\x00\x12\x00\xff\xff\x48\x00\xff\xff\x3d\x00\xff\xff\x3f\x00\xff\xff\x41\x00\x1b\x00\x1c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\xff\xff\x4b\x00\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\x37\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\xff\xff\x3d\x00\xff\xff\x3f\x00\x33\x00\x41\x00\xff\xff\xff\xff\x37\x00\x38\x00\x12\x00\xff\xff\x48\x00\xff\xff\x3d\x00\xff\xff\x3f\x00\xff\xff\x41\x00\x1b\x00\x1c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\xff\xff\x4b\x00\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\x37\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\xff\xff\x3d\x00\xff\xff\x3f\x00\x33\x00\x41\x00\xff\xff\xff\xff\x37\x00\x38\x00\x12\x00\xff\xff\x48\x00\xff\xff\x3d\x00\xff\xff\x3f\x00\xff\xff\x41\x00\x1b\x00\x1c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\xff\xff\x4b\x00\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\x37\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\xff\xff\x3d\x00\xff\xff\x3f\x00\x33\x00\x41\x00\xff\xff\xff\xff\x37\x00\x38\x00\x12\x00\xff\xff\x48\x00\xff\xff\x3d\x00\xff\xff\x3f\x00\xff\xff\x41\x00\x1b\x00\x1c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\xff\xff\x4b\x00\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\x37\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\xff\xff\x3d\x00\xff\xff\x3f\x00\x33\x00\x41\x00\xff\xff\xff\xff\x37\x00\x38\x00\x12\x00\xff\xff\x48\x00\xff\xff\x3d\x00\xff\xff\x3f\x00\xff\xff\x41\x00\x1b\x00\x1c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\xff\xff\x4b\x00\xff\xff\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x11\x00\xff\xff\xff\xff\xff\xff\x33\x00\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\xff\xff\x3f\x00\xff\xff\x41\x00\xff\xff\xff\xff\x26\x00\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x09\x00\x4b\x00\xff\xff\xff\xff\xff\xff\x31\x00\x0f\x00\x33\x00\x34\x00\xff\xff\x13\x00\x14\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x27\x00\x09\x00\xff\xff\x0b\x00\xff\xff\x2c\x00\x2d\x00\x0f\x00\x2f\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x09\x00\xff\xff\x0b\x00\xff\xff\xff\xff\xff\xff\x0f\x00\xff\xff\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\xff\xff\x09\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x0f\x00\xff\xff\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\xff\xff\x09\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x0f\x00\xff\xff\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\xff\xff\x09\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x0f\x00\xff\xff\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\xff\xff\x09\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x0f\x00\xff\xff\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x09\x00\xff\xff\x0b\x00\xff\xff\xff\xff\xff\xff\x0f\x00\xff\xff\xff\xff\xff\xff\x13\x00\x14\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\x0b\x00\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x09\x00\xff\xff\x0b\x00\xff\xff\xff\xff\xff\xff\x0f\x00\x27\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\x09\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x0f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\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"#++happyTable :: HappyAddr+happyTable = HappyA# "\x00\x00\x6d\x02\xad\x01\x73\x02\x53\x01\xeb\x00\xc5\x01\xcb\x01\xcc\x01\xc6\x01\xc7\x01\x12\x00\x1f\x02\xc5\x01\x8a\x02\x42\x00\xd4\x01\x43\x00\x83\x02\x97\x01\xec\x00\x15\x00\x16\x00\x17\x00\xe4\x00\x19\x00\x1a\x00\x1b\x00\x62\x01\x05\x00\x06\x00\xc5\x01\xcb\x01\xad\x01\xd4\x01\xb2\x01\xd5\x01\xcb\x01\xcc\x01\x0e\x00\x0f\x00\x79\x00\x63\x01\x46\x00\x7e\x02\x64\x01\x10\x00\x7a\x00\x47\x02\xc5\x01\x7f\x00\x3b\x01\xd4\x01\x33\x00\xd5\x01\xae\x01\xaf\x01\xb0\x01\x7f\x02\xcb\x01\xcc\x01\xed\x00\x20\x02\xd9\x00\xda\x00\xdb\x00\xee\x00\xdc\x00\xef\x00\xcd\x01\xc8\x01\xf0\x00\x87\x02\xf1\x00\xf2\x00\xf3\x00\xf4\x00\x6e\x02\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xae\x01\x98\x01\x3d\x02\x97\x01\xfd\x00\x33\x00\x33\x00\xfe\x00\xff\x00\x00\x01\xd6\x01\x7f\x00\x01\x01\xcd\x01\x02\x01\x11\x00\x03\x01\x04\x01\x05\x01\x06\x01\x07\x01\x08\x01\x09\x01\x0a\x01\x0b\x01\x0c\x01\x79\x00\x32\x02\x54\x02\xce\x01\xc9\x01\xeb\x00\x7a\x00\x47\x02\x07\x00\x45\x02\x6f\x02\x12\x00\x08\x00\xdd\x00\x09\x00\x0a\x00\x78\x02\x0b\x00\x25\x02\x0c\x00\xec\x00\x15\x00\x16\x00\x17\x00\xe4\x00\x19\x00\x1a\x00\x1b\x00\x07\x00\x62\x01\x11\x00\xd7\x01\x08\x00\xce\x01\x09\x00\x0a\x00\x12\x00\x0b\x00\x11\x00\x0c\x00\x21\x01\x53\x01\x8b\x02\x95\x01\x12\x00\x98\x01\x64\x01\x21\x02\x33\x00\x34\x00\x19\x00\x1a\x00\xcf\x00\x52\x00\xff\x01\x62\x01\x7f\x00\x66\x02\x19\x00\x1a\x00\xcf\x00\xed\x00\x90\x01\x23\x02\xf5\x01\x24\x01\xee\x00\x69\x02\xef\x00\x26\x02\x33\x00\xf0\x00\x64\x01\xf1\x00\xf2\x00\xf3\x00\xf4\x00\x6b\x02\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\x53\x01\x48\x02\xc5\x01\xad\x01\xfd\x00\xc6\x01\xc7\x01\xfe\x00\xff\x00\x00\x01\xb3\x01\x22\x02\x01\x01\x01\x02\x02\x01\xb3\x01\x03\x01\x04\x01\x05\x01\x06\x01\x07\x01\x08\x01\x09\x01\x0a\x01\x0b\x01\x0c\x01\xeb\x00\x24\x02\xc3\x01\x8b\x01\x76\x02\x11\x00\x12\x00\x33\x00\x34\x00\x12\x00\x0d\x01\x12\x00\xaa\x01\x79\x02\xc4\x01\xec\x00\x15\x00\x16\x00\x17\x00\xe4\x00\x19\x00\x1a\x00\x1b\x00\x21\x01\x66\x00\x19\x00\x1a\x00\xcf\x00\x21\x01\x11\x00\xae\x01\x86\xff\xb2\x01\xe9\x01\xe4\x01\x12\x00\x3e\x02\xb5\x01\xb6\x01\x78\x00\x43\x02\xb4\x01\xb5\x01\xb6\x01\x86\xff\xe5\x01\x6f\x01\x23\x01\x24\x01\x46\x00\x66\x00\x22\x01\x23\x01\x24\x01\x46\x00\x50\x01\xed\x00\xdc\x01\x12\x02\x54\x01\x78\x00\xee\x00\x3e\x01\xef\x00\x78\x00\x12\x02\xf0\x00\x3f\x02\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xe4\x01\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\x2b\x00\x6e\x00\xe5\x01\x76\x00\xfd\x00\x40\x02\x77\x00\xfe\x00\xff\x00\x00\x01\xd0\x00\x64\x00\x01\x01\x6f\x00\x02\x01\x70\x00\x03\x01\x04\x01\x05\x01\x06\x01\x07\x01\x08\x01\x09\x01\x0a\x01\x0b\x01\x0c\x01\xeb\x00\x79\x00\x19\x02\x22\x00\x1a\x02\x11\x00\x12\x00\x7a\x00\x7d\x00\x51\x02\x89\x02\x12\x00\x23\x00\x24\x00\x59\x02\xec\x00\x15\x00\x16\x00\x17\x00\xe4\x00\x19\x00\x1a\x00\x1b\x00\x5d\x02\x73\x00\x19\x00\x1a\x00\xe6\x01\x27\x00\x28\x00\x29\x00\x2a\x00\x27\xff\x27\xff\x61\x02\x5b\x02\x57\x00\x27\xff\x5c\x02\x27\xff\x2d\x00\x2e\x00\x03\x02\x27\xff\x46\x00\x27\xff\x68\x00\x27\xff\x78\x02\x06\x02\x75\x00\x0d\x02\xdc\x01\xdd\x01\x27\xff\x08\x02\xed\x00\x33\x00\x34\x00\x4b\x02\x35\x00\xee\x00\x42\x00\xef\x00\x43\x00\x7c\x02\xf0\x00\x09\x02\xf1\x00\xf2\x00\xf3\x00\xf4\x00\x0a\x02\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\x4b\x02\xe9\x00\x46\x00\xea\x00\xfd\x00\xeb\x00\x7d\x02\xfe\x00\xff\x00\x00\x01\xdc\x01\xde\x01\x01\x01\x42\x00\x02\x01\x43\x00\x03\x01\x04\x01\x05\x01\x06\x01\x07\x01\x08\x01\x09\x01\x0a\x01\x0b\x01\x0c\x01\xeb\x00\x79\x00\x0e\x02\x22\x00\x15\x02\x11\x00\x12\x00\x7a\x00\xce\x00\x2f\x02\x0d\x01\x12\x00\x23\x00\x24\x00\x30\x02\xec\x00\x15\x00\x16\x00\x17\x00\xe4\x00\x19\x00\x1a\x00\x1b\x00\x33\x02\xe5\x01\x19\x00\x1a\x00\xe6\x01\x27\x00\x28\x00\x29\x00\x2a\x00\x50\x00\x51\x00\x80\x02\x95\x01\x57\x00\x52\x00\xac\x01\x41\xff\x2d\x00\x2e\x00\x37\x02\x45\x01\x46\x00\x46\x01\x68\x00\x47\x01\x69\x00\x4b\x02\x75\x00\x39\x02\xdc\x01\xdf\x01\x33\x00\x4c\x02\xed\x00\x33\x00\x34\x00\x4b\x02\x35\x00\xc4\x01\xc1\x01\xef\x00\xbe\x01\x4f\x02\xf0\x00\xcf\x01\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xe7\x01\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\x9d\x01\x17\x02\xe9\x01\x18\x02\xfd\x00\xeb\x01\x78\x00\xfe\x00\xff\x00\x00\x01\x33\x00\x7c\xff\x01\x01\x7c\xff\x02\x01\x7c\xff\x03\x01\x04\x01\x05\x01\x06\x01\x07\x01\x08\x01\x09\x01\x0a\x01\x0b\x01\x0c\x01\x97\x01\x21\x00\x81\x02\x82\x02\x79\x00\x46\x00\x0f\x01\x10\x01\x11\x01\x0f\x00\x7a\x00\x7b\x00\xec\x01\x47\x00\xed\x01\x12\x01\x13\x01\x14\x01\x15\x01\x71\x02\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x23\x00\x24\x00\xee\x01\x1d\x01\xd9\x00\xda\x00\xdb\x00\x48\x00\xdc\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\xb9\x01\x49\x02\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x4d\x00\x4e\x00\x1e\x01\xef\x01\x1f\x01\x0e\x00\x0f\x00\x52\x00\x2d\x00\x2e\x00\xf0\x01\x2f\x00\x10\x00\xe9\x00\x68\x00\x3d\x01\x69\x00\x3e\x01\x75\x00\x46\x00\xfd\x01\x98\x01\xff\x01\x20\x01\x33\x00\x33\x00\x34\x00\x47\x00\x35\x00\x97\x01\x21\x00\xcb\x01\x55\x02\x79\x00\x46\x00\x0f\x01\x10\x01\x11\x01\x0f\x00\x7a\x00\x7c\x00\x01\x02\x47\x00\x60\x01\x12\x01\x13\x01\x14\x01\x15\x01\xdd\x00\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x23\x00\x24\x00\x79\x00\x1d\x01\x26\x02\xdf\x00\x62\x00\x41\x01\x7a\x00\x7d\x00\xc5\x01\x5a\x01\x64\x01\xc6\x01\x13\x02\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x43\x01\x62\x00\x1e\x01\x67\x01\x1f\x01\xcb\x01\x56\x02\x52\x00\x2d\x00\x2e\x00\x6a\x01\x2f\x00\x6d\x01\x5b\x00\x68\x00\x40\x01\x69\x00\x41\x01\x75\x00\xcb\x01\x57\x02\x98\x01\x7f\x01\x20\x01\x33\x00\x33\x00\x34\x00\x81\x01\x35\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\x21\x00\xe0\x01\xe1\x01\xe2\x01\x46\x00\x0f\x01\x10\x01\x11\x01\x0f\x00\x5b\x00\x82\x01\x5c\x00\x47\x00\x5d\x00\x12\x01\x13\x01\x14\x01\x15\x01\x83\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x23\x00\x24\x00\x07\x00\x1d\x01\xcb\x01\x58\x02\x08\x00\x41\x01\x80\x00\x0a\x00\x84\x01\x5b\x01\x85\x01\x21\x00\x87\x01\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x43\x01\x62\x00\x1e\x01\xc5\x01\x1f\x01\x88\x01\xc6\x01\x14\x02\x2d\x00\x2e\x00\x22\x00\x2f\x00\xc5\x01\x89\x01\x68\x00\xd4\x01\x69\x00\x84\x02\x75\x00\x23\x00\x24\x00\x25\x00\x8c\x01\x20\x01\xc5\x01\x33\x00\x34\x00\xd4\x01\x35\x00\x85\x02\xa3\x01\xd6\x00\xd7\x00\x8d\x01\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x10\x02\xe2\x01\x7c\x02\x2b\x00\x2c\x00\x21\x00\x07\x00\x8e\x01\x2d\x00\x2e\x00\x08\x00\x2f\x00\x81\x00\x0a\x00\x30\x00\x90\x01\x31\x00\x42\x00\x32\x00\x43\x00\xc5\x01\x11\x00\x22\x00\xc6\x01\x2e\x02\x33\x00\x34\x00\x12\x00\x35\x00\xcb\x01\x2a\x02\x23\x00\x24\x00\x25\x00\xd9\x00\xda\x00\xdb\x00\xe3\x00\x16\x00\x17\x00\xe4\x00\x19\x00\x1a\x00\x1b\x00\x1a\x02\x1b\x02\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x27\x02\x28\x02\xa9\x01\x2b\x00\x2c\x00\x21\x00\x92\x01\xc5\x01\x2d\x00\x2e\x00\xd4\x01\x2f\x00\x86\x02\x98\x01\x30\x00\x9d\x01\x31\x00\x42\x00\x32\x00\x43\x00\x9a\x01\x11\x00\x22\x00\x2b\x02\x2c\x02\x33\x00\x34\x00\x12\x00\x35\x00\xb9\x01\xba\x01\x23\x00\x24\x00\x25\x00\x94\x01\x95\x01\x6c\x00\x1f\x00\x72\x00\x17\x00\x73\x00\x19\x00\x1a\x00\x1b\x00\xa2\x01\x46\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x35\x00\x04\x00\x47\x00\x2b\x00\x2c\x00\x21\x00\x4d\x01\xc5\x01\x2d\x00\x2e\x00\xd4\x01\x2f\x00\x67\x02\xa7\x01\x30\x00\xe0\x00\x31\x00\x42\x00\x32\x00\x43\x00\x4e\x01\x5d\x00\x22\x00\xdd\x00\x6a\x00\x33\x00\x34\x00\x82\x00\x35\x00\x50\x00\x51\x00\x23\x00\x24\x00\x25\x00\x52\x00\xd0\x01\xdf\x00\x62\x00\x78\x00\x04\x00\x64\x00\x4e\x02\x65\x00\x89\x02\x66\x00\x46\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x33\x00\x33\x00\x47\x00\x2b\x00\x2c\x00\x21\x00\x53\x02\xc5\x01\x2d\x00\x2e\x00\xd4\x01\x2f\x00\x68\x02\xe5\x01\x30\x00\x6c\x00\x31\x00\x65\x02\x32\x00\x3d\x00\x66\x02\x11\x00\x22\x00\xdd\x00\xe5\x01\x33\x00\x34\x00\x12\x00\x35\x00\x33\x00\x34\x00\x23\x00\x24\x00\x25\x00\x6b\x02\xd1\x01\xdf\x00\x62\x00\xf8\x01\x17\x00\x34\x01\x19\x00\x1a\x00\x1b\x00\x21\x00\x6d\x02\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x72\x02\x73\x02\x75\x02\x2b\x00\x2c\x00\xf9\x01\xfa\x01\xfb\x01\x2d\x00\x2e\x00\x22\x00\x2f\x00\x33\x00\x42\x02\x30\x00\x46\x00\x31\x00\xb8\x01\x32\x00\x23\x00\x24\x00\x25\x00\x33\x00\x47\x02\xc5\x01\x33\x00\x34\x00\xd4\x01\x35\x00\x1d\x02\xbc\x01\x4e\x02\x53\x02\x46\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x33\x00\x5b\x02\x47\x00\x2b\x00\x2c\x00\x21\x00\xe5\x01\x5f\x02\x2d\x00\x2e\x00\x60\x02\x2f\x00\x61\x02\x63\x02\x30\x00\x64\x02\x31\x00\xe2\x00\x32\x00\x3d\x00\xeb\x01\x11\x00\x22\x00\xdd\x00\xe2\x00\x33\x00\x34\x00\x12\x00\x35\x00\x08\x02\xe2\x00\x23\x00\x24\x00\x25\x00\xc0\x01\xd2\x01\xdf\x00\x62\x00\xf8\x01\x17\x00\x34\x01\x19\x00\x1a\x00\x1b\x00\x21\x00\x05\x02\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x06\x02\x0c\x02\x81\x01\x2b\x00\x2c\x00\xf9\x01\xfa\x01\xfc\x01\x2d\x00\x2e\x00\x22\x00\x2f\x00\x10\x02\x1d\x02\x30\x00\x46\x00\x31\x00\x2a\x02\x32\x00\x23\x00\x24\x00\x25\x00\x33\x00\x2e\x02\x33\x00\x33\x00\x34\x00\x35\x02\x35\x00\x6c\x00\x36\x02\x37\x02\x3c\x02\x46\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x33\x00\x33\x00\x47\x00\x2b\x00\x2c\x00\x21\x00\x39\x02\x3b\x02\x2d\x00\x2e\x00\xb8\x01\x2f\x00\xc0\x01\xbc\x01\x30\x00\x33\x00\x31\x00\xf7\x01\x32\x00\x3d\x00\x9c\x01\x11\x00\x22\x00\xdd\x00\xeb\x01\x33\x00\x34\x00\x12\x00\x35\x00\xf2\x01\xf3\x01\x23\x00\x24\x00\x25\x00\xf4\x01\xd3\x01\xdf\x00\x62\x00\x72\x00\x17\x00\x33\x00\x19\x00\x1a\x00\xe7\x00\x21\x00\x03\x02\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x43\xff\x67\x01\x44\xff\x2b\x00\x2c\x00\x40\xff\x3e\xff\x3f\xff\x2d\x00\x2e\x00\x22\x00\x2f\x00\x66\x01\x69\x01\x30\x00\x46\x00\x31\x00\x6c\x01\x32\x00\x23\x00\x24\x00\x25\x00\x6a\x01\x71\x01\x7e\x01\x33\x00\x34\x00\x73\x01\x35\x00\x6f\x01\x12\x00\x33\x00\x21\x00\x72\x01\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xd9\x01\xda\x01\x81\x01\x2b\x00\x2c\x00\x19\x00\x1a\x00\x55\x00\x2d\x00\x2e\x00\x22\x00\x2f\x00\x33\x00\xdb\x01\x30\x00\xdc\x01\x31\x00\x33\x00\x32\x00\x23\x00\x24\x00\x6c\x00\x33\x00\x87\x01\x11\x00\x33\x00\x34\x00\x8b\x01\x35\x00\x92\x01\x12\x00\x94\x01\x46\x00\x9a\x01\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x9c\x01\x47\x00\x77\x00\x21\x00\x57\x00\x19\x00\x1a\x00\xe2\x00\x2d\x00\x2e\x00\xe2\x00\x2f\x00\x9f\x01\xa1\x01\x68\x00\x33\x00\x69\x00\x42\x00\x75\x00\x43\x00\x22\x00\xa5\x01\x5e\x00\xa6\x01\xa7\x01\x33\x00\x34\x00\xdb\x00\x35\x00\x23\x00\x24\x00\x25\x00\x5f\x00\x60\x00\x11\x00\x61\x00\x62\x00\x21\x01\xe2\x00\x33\x00\x12\x00\x2d\x01\x21\x00\x26\x01\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2a\x01\x48\x01\x4b\x01\x2b\x00\x2c\x00\x19\x00\x1a\x00\x55\x00\x2d\x00\x2e\x00\x22\x00\x2f\x00\x4c\x01\x4d\x01\x30\x00\x51\x01\x31\x00\x52\x01\x32\x00\x23\x00\x24\x00\x53\x01\x71\x00\x6c\x00\xff\xff\x33\x00\x34\x00\x33\x00\x35\x00\x78\x00\xff\xff\x46\x00\x79\x00\x46\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x47\x00\xff\xff\x47\x00\x21\x00\x57\x00\x00\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x00\x00\x68\x00\x00\x00\x69\x00\x42\x00\x75\x00\x43\x00\x22\x00\xdd\x00\x00\x00\x41\x01\x00\x00\x33\x00\x34\x00\x42\x01\x35\x00\x23\x00\x24\x00\x25\x00\x00\x00\x9f\x01\xdf\x00\x62\x00\x43\x01\x62\x00\x00\x00\x00\x00\x00\x00\x00\x00\x21\x00\x00\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x22\x00\x2f\x00\x00\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x23\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x46\x00\x00\x00\x46\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x47\x00\x00\x00\x47\x00\x21\x00\x57\x00\x00\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x73\xff\x2f\x00\x00\x00\x73\xff\x68\x00\x00\x00\x69\x00\x00\x00\x75\x00\x00\x00\x22\x00\xdd\x00\x00\x00\x41\x01\x00\x00\x33\x00\x34\x00\x49\x01\x35\x00\x23\x00\x24\x00\x25\x00\x00\x00\xa1\x01\xdf\x00\x62\x00\x43\x01\x62\x00\x00\x00\x00\x00\x00\x00\x00\x00\x21\x00\x00\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x22\x00\x2f\x00\x00\x00\x00\x00\x30\x00\x00\x00\x31\x00\x00\x00\x32\x00\x23\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x46\x00\x00\x00\x00\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x47\x00\x00\x00\x00\x00\x21\x00\x57\x00\x00\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x00\x00\x68\x00\x00\x00\x69\x00\x00\x00\x75\x00\x58\x01\x22\x00\xdd\x00\x00\x00\x00\x00\x00\x00\x33\x00\x34\x00\x00\x00\x35\x00\x23\x00\x24\x00\x00\x00\x00\x00\xde\x00\xdf\x00\x62\x00\x7a\x02\xd4\x00\xd5\x00\xd6\x00\xd7\x00\x00\x00\x21\x00\x00\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x22\x00\x2f\x00\x00\x00\x00\x00\x68\x00\x5a\x01\x69\x00\x00\x00\x75\x00\x23\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x46\x00\x00\x00\x00\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x47\x00\x00\x00\x00\x00\x21\x00\x57\x00\x00\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x00\x00\x2f\x00\x00\x00\x00\x00\x68\x00\x00\x00\x69\x00\x00\x00\x75\x00\x39\x01\x22\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x33\x00\x34\x00\x00\x00\x35\x00\x23\x00\x24\x00\x00\x00\x28\x01\x00\x00\x61\x00\x62\x00\x75\x02\xd4\x00\xd5\x00\xd6\x00\xd7\x00\x00\x00\x21\x00\x00\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x22\x00\x2f\x00\x00\x00\x00\x00\x68\x00\x3b\x01\x69\x00\x00\x00\x75\x00\x23\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x00\x34\x00\x00\x00\x35\x00\x3c\x02\xd4\x00\xd5\x00\xd6\x00\xd7\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x50\x00\x51\x00\x57\x00\x00\x00\x00\x00\x52\x00\x2d\x00\x2e\x00\x22\x00\x2f\x00\x00\x00\x64\x00\x68\x00\x65\x00\x69\x00\x66\x00\x75\x00\x23\x00\x24\x00\x00\x00\x00\x00\x00\x00\x33\x00\x33\x00\x34\x00\x00\x00\x35\x00\x50\x00\x51\x00\x00\x00\x00\x00\x00\x00\x52\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x45\x01\x00\x00\x46\x01\x57\x00\x47\x01\x00\x00\x00\x00\x2d\x00\x2e\x00\x22\x00\x00\x00\x33\x00\x00\x00\x68\x00\x00\x00\x69\x00\x00\x00\x6a\x00\x23\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x00\x34\x00\x00\x00\x35\x00\x50\x00\x51\x00\x00\x00\x00\x00\x00\x00\x52\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x64\x00\x00\x00\x65\x00\x57\x00\x66\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x22\x00\x00\x00\x33\x00\x00\x00\x68\x00\x00\x00\x69\x00\x00\x00\x75\x00\x23\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x00\x34\x00\x00\x00\x35\x00\x50\x00\x51\x00\x00\x00\x00\x00\x00\x00\x52\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x45\x01\x00\x00\x46\x01\x57\x00\x47\x01\x00\x00\x00\x00\x2d\x00\x2e\x00\x22\x00\x00\x00\x33\x00\x00\x00\x68\x00\x00\x00\xd2\x00\x00\x00\x75\x00\x23\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x00\x34\x00\x00\x00\x35\x00\x50\x00\x51\x00\x00\x00\x00\x00\x00\x00\x52\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x53\x00\x00\x00\x54\x00\x57\x00\x55\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x22\x00\x00\x00\x33\x00\x00\x00\x68\x00\x00\x00\x69\x00\x00\x00\x75\x00\x23\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x00\x34\x00\x00\x00\x35\x00\x50\x00\x51\x00\x00\x00\x00\x00\x00\x00\x52\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x64\x00\x00\x00\x65\x00\x57\x00\x66\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x22\x00\x00\x00\x33\x00\x00\x00\x58\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x23\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x00\x34\x00\x00\x00\x35\x00\x00\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x47\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x69\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x33\x00\x34\x00\x11\x00\x35\x00\x00\x00\x00\x00\x00\x00\x2b\x01\x12\x00\x61\x00\x62\x00\x00\x00\x37\x00\x26\x01\xb8\x01\xd4\x00\xd5\x00\xd6\x00\xd7\x00\x33\x01\x17\x00\x34\x01\x19\x00\x1a\x00\x1b\x00\xab\x01\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\x00\x00\x3b\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x35\x01\x36\x01\x12\x00\x37\x01\x00\x00\x00\x00\x37\x00\x38\x00\x00\x00\x00\x00\x3f\x00\x14\x00\x15\x00\x3a\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x31\x01\x3d\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x00\x00\x00\x00\x3f\x00\x14\x00\x15\x00\x3a\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x36\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x40\x00\x12\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x00\x00\x00\x00\x39\x00\x14\x00\x15\x00\x3a\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x11\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x30\x01\x12\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x00\x00\x00\x00\x43\x00\x14\x00\x15\x00\x3a\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x36\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x32\x01\x12\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x00\x00\x00\x00\x39\x00\x14\x00\x15\x00\x3a\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x11\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x3b\x00\x12\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x00\x00\x00\x00\x43\x00\x14\x00\x15\x00\x3a\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x44\x00\x11\x00\x00\x00\x58\x01\x00\x00\x00\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x27\x01\x38\x00\xa9\x01\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x11\x00\x00\x00\x39\x01\x00\x00\x00\x00\x00\x00\x12\x00\x40\x00\x00\x00\x00\x00\x27\x01\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x40\x00\x00\x00\x00\x00\x37\x00\x26\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x3b\x00\x00\x00\x00\x00\x37\x00\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x44\x00\x00\x00\x00\x00\x5c\x01\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x2d\x01\x00\x00\x00\x00\x5d\x01\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x2e\x01\x00\x00\x00\x00\x5e\x01\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x30\x01\x00\x00\x00\x00\x5f\x01\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x31\x01\x00\x00\x00\x00\x37\x00\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x30\x01\x00\x00\x00\x00\x37\x00\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x31\x01\x00\x00\x00\x00\x37\x00\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x32\x01\x00\x00\x00\x00\x37\x00\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x3b\x00\x00\x00\x00\x00\x37\x00\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x40\x00\x00\x00\x00\x00\x37\x00\x26\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x3b\x00\x00\x00\x00\x00\x27\x01\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x40\x00\x00\x00\x00\x00\x37\x00\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x44\x00\x00\x00\x00\x00\x37\x00\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x2d\x01\x00\x00\x00\x00\x37\x00\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x2e\x01\x00\x00\x00\x00\x37\x00\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x2f\x01\x00\x00\x00\x00\x37\x00\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x17\x00\x00\x00\x19\x00\x1a\x00\xe7\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x12\x00\x44\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\x3f\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x02\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x02\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x02\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4e\x02\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x50\x02\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x02\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x02\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x02\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbc\x01\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x01\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x01\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf4\x01\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf7\x01\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x01\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x01\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x01\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6c\x01\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x01\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe5\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x36\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2a\x01\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x01\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x71\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x11\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x75\x01\x76\x01\x77\x01\x78\x01\x79\x01\x7a\x01\x7b\x01\x7c\x01\x7d\x01\x7e\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\x00\x00\x00\x00\x00"#++happyReduceArr = Happy_Data_Array.array (3, 370) [+	(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),+	(131 , happyReduce_131),+	(132 , happyReduce_132),+	(133 , happyReduce_133),+	(134 , happyReduce_134),+	(135 , happyReduce_135),+	(136 , happyReduce_136),+	(137 , happyReduce_137),+	(138 , happyReduce_138),+	(139 , happyReduce_139),+	(140 , happyReduce_140),+	(141 , happyReduce_141),+	(142 , happyReduce_142),+	(143 , happyReduce_143),+	(144 , happyReduce_144),+	(145 , happyReduce_145),+	(146 , happyReduce_146),+	(147 , happyReduce_147),+	(148 , happyReduce_148),+	(149 , happyReduce_149),+	(150 , happyReduce_150),+	(151 , happyReduce_151),+	(152 , happyReduce_152),+	(153 , happyReduce_153),+	(154 , happyReduce_154),+	(155 , happyReduce_155),+	(156 , happyReduce_156),+	(157 , happyReduce_157),+	(158 , happyReduce_158),+	(159 , happyReduce_159),+	(160 , happyReduce_160),+	(161 , happyReduce_161),+	(162 , happyReduce_162),+	(163 , happyReduce_163),+	(164 , happyReduce_164),+	(165 , happyReduce_165),+	(166 , happyReduce_166),+	(167 , happyReduce_167),+	(168 , happyReduce_168),+	(169 , happyReduce_169),+	(170 , happyReduce_170),+	(171 , happyReduce_171),+	(172 , happyReduce_172),+	(173 , happyReduce_173),+	(174 , happyReduce_174),+	(175 , happyReduce_175),+	(176 , happyReduce_176),+	(177 , happyReduce_177),+	(178 , happyReduce_178),+	(179 , happyReduce_179),+	(180 , happyReduce_180),+	(181 , happyReduce_181),+	(182 , happyReduce_182),+	(183 , happyReduce_183),+	(184 , happyReduce_184),+	(185 , happyReduce_185),+	(186 , happyReduce_186),+	(187 , happyReduce_187),+	(188 , happyReduce_188),+	(189 , happyReduce_189),+	(190 , happyReduce_190),+	(191 , happyReduce_191),+	(192 , happyReduce_192),+	(193 , happyReduce_193),+	(194 , happyReduce_194),+	(195 , happyReduce_195),+	(196 , happyReduce_196),+	(197 , happyReduce_197),+	(198 , happyReduce_198),+	(199 , happyReduce_199),+	(200 , happyReduce_200),+	(201 , happyReduce_201),+	(202 , happyReduce_202),+	(203 , happyReduce_203),+	(204 , happyReduce_204),+	(205 , happyReduce_205),+	(206 , happyReduce_206),+	(207 , happyReduce_207),+	(208 , happyReduce_208),+	(209 , happyReduce_209),+	(210 , happyReduce_210),+	(211 , happyReduce_211),+	(212 , happyReduce_212),+	(213 , happyReduce_213),+	(214 , happyReduce_214),+	(215 , happyReduce_215),+	(216 , happyReduce_216),+	(217 , happyReduce_217),+	(218 , happyReduce_218),+	(219 , happyReduce_219),+	(220 , happyReduce_220),+	(221 , happyReduce_221),+	(222 , happyReduce_222),+	(223 , happyReduce_223),+	(224 , happyReduce_224),+	(225 , happyReduce_225),+	(226 , happyReduce_226),+	(227 , happyReduce_227),+	(228 , happyReduce_228),+	(229 , happyReduce_229),+	(230 , happyReduce_230),+	(231 , happyReduce_231),+	(232 , happyReduce_232),+	(233 , happyReduce_233),+	(234 , happyReduce_234),+	(235 , happyReduce_235),+	(236 , happyReduce_236),+	(237 , happyReduce_237),+	(238 , happyReduce_238),+	(239 , happyReduce_239),+	(240 , happyReduce_240),+	(241 , happyReduce_241),+	(242 , happyReduce_242),+	(243 , happyReduce_243),+	(244 , happyReduce_244),+	(245 , happyReduce_245),+	(246 , happyReduce_246),+	(247 , happyReduce_247),+	(248 , happyReduce_248),+	(249 , happyReduce_249),+	(250 , happyReduce_250),+	(251 , happyReduce_251),+	(252 , happyReduce_252),+	(253 , happyReduce_253),+	(254 , happyReduce_254),+	(255 , happyReduce_255),+	(256 , happyReduce_256),+	(257 , happyReduce_257),+	(258 , happyReduce_258),+	(259 , happyReduce_259),+	(260 , happyReduce_260),+	(261 , happyReduce_261),+	(262 , happyReduce_262),+	(263 , happyReduce_263),+	(264 , happyReduce_264),+	(265 , happyReduce_265),+	(266 , happyReduce_266),+	(267 , happyReduce_267),+	(268 , happyReduce_268),+	(269 , happyReduce_269),+	(270 , happyReduce_270),+	(271 , happyReduce_271),+	(272 , happyReduce_272),+	(273 , happyReduce_273),+	(274 , happyReduce_274),+	(275 , happyReduce_275),+	(276 , happyReduce_276),+	(277 , happyReduce_277),+	(278 , happyReduce_278),+	(279 , happyReduce_279),+	(280 , happyReduce_280),+	(281 , happyReduce_281),+	(282 , happyReduce_282),+	(283 , happyReduce_283),+	(284 , happyReduce_284),+	(285 , happyReduce_285),+	(286 , happyReduce_286),+	(287 , happyReduce_287),+	(288 , happyReduce_288),+	(289 , happyReduce_289),+	(290 , happyReduce_290),+	(291 , happyReduce_291),+	(292 , happyReduce_292),+	(293 , happyReduce_293),+	(294 , happyReduce_294),+	(295 , happyReduce_295),+	(296 , happyReduce_296),+	(297 , happyReduce_297),+	(298 , happyReduce_298),+	(299 , happyReduce_299),+	(300 , happyReduce_300),+	(301 , happyReduce_301),+	(302 , happyReduce_302),+	(303 , happyReduce_303),+	(304 , happyReduce_304),+	(305 , happyReduce_305),+	(306 , happyReduce_306),+	(307 , happyReduce_307),+	(308 , happyReduce_308),+	(309 , happyReduce_309),+	(310 , happyReduce_310),+	(311 , happyReduce_311),+	(312 , happyReduce_312),+	(313 , happyReduce_313),+	(314 , happyReduce_314),+	(315 , happyReduce_315),+	(316 , happyReduce_316),+	(317 , happyReduce_317),+	(318 , happyReduce_318),+	(319 , happyReduce_319),+	(320 , happyReduce_320),+	(321 , happyReduce_321),+	(322 , happyReduce_322),+	(323 , happyReduce_323),+	(324 , happyReduce_324),+	(325 , happyReduce_325),+	(326 , happyReduce_326),+	(327 , happyReduce_327),+	(328 , happyReduce_328),+	(329 , happyReduce_329),+	(330 , happyReduce_330),+	(331 , happyReduce_331),+	(332 , happyReduce_332),+	(333 , happyReduce_333),+	(334 , happyReduce_334),+	(335 , happyReduce_335),+	(336 , happyReduce_336),+	(337 , happyReduce_337),+	(338 , happyReduce_338),+	(339 , happyReduce_339),+	(340 , happyReduce_340),+	(341 , happyReduce_341),+	(342 , happyReduce_342),+	(343 , happyReduce_343),+	(344 , happyReduce_344),+	(345 , happyReduce_345),+	(346 , happyReduce_346),+	(347 , happyReduce_347),+	(348 , happyReduce_348),+	(349 , happyReduce_349),+	(350 , happyReduce_350),+	(351 , happyReduce_351),+	(352 , happyReduce_352),+	(353 , happyReduce_353),+	(354 , happyReduce_354),+	(355 , happyReduce_355),+	(356 , happyReduce_356),+	(357 , happyReduce_357),+	(358 , happyReduce_358),+	(359 , happyReduce_359),+	(360 , happyReduce_360),+	(361 , happyReduce_361),+	(362 , happyReduce_362),+	(363 , happyReduce_363),+	(364 , happyReduce_364),+	(365 , happyReduce_365),+	(366 , happyReduce_366),+	(367 , happyReduce_367),+	(368 , happyReduce_368),+	(369 , happyReduce_369),+	(370 , happyReduce_370)+	]++happy_n_terms = 77 :: Int+happy_n_nonterms = 127 :: Int++happyReduce_3 = happySpecReduce_1  0# happyReduction_3+happyReduction_3 happy_x_1+	 =  case happyOut7 happy_x_1 of { happy_var_1 -> +	happyIn6+		 (reverse happy_var_1+	)}++happyReduce_4 = happySpecReduce_2  1# happyReduction_4+happyReduction_4 happy_x_2+	happy_x_1+	 =  case happyOut7 happy_x_1 of { happy_var_1 -> +	case happyOut8 happy_x_2 of { happy_var_2 -> +	happyIn7+		 (happy_var_2 : happy_var_1+	)}}++happyReduce_5 = happySpecReduce_0  1# happyReduction_5+happyReduction_5  =  happyIn7+		 ([]+	)++happyReduce_6 = happySpecReduce_1  2# happyReduction_6+happyReduction_6 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwLet happy_var_1) -> +	happyIn8+		 (TokKeyword KwLet happy_var_1+	)}++happyReduce_7 = happySpecReduce_1  2# happyReduction_7+happyReduction_7 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwIn happy_var_1) -> +	happyIn8+		 (TokKeyword KwIn happy_var_1+	)}++happyReduce_8 = happySpecReduce_1  2# happyReduction_8+happyReduction_8 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwWhere happy_var_1) -> +	happyIn8+		 (TokKeyword KwWhere happy_var_1+	)}++happyReduce_9 = happySpecReduce_1  2# happyReduction_9+happyReduction_9 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwWith happy_var_1) -> +	happyIn8+		 (TokKeyword KwWith happy_var_1+	)}++happyReduce_10 = happySpecReduce_1  2# happyReduction_10+happyReduction_10 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwRewrite happy_var_1) -> +	happyIn8+		 (TokKeyword KwRewrite happy_var_1+	)}++happyReduce_11 = happySpecReduce_1  2# happyReduction_11+happyReduction_11 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwPostulate happy_var_1) -> +	happyIn8+		 (TokKeyword KwPostulate happy_var_1+	)}++happyReduce_12 = happySpecReduce_1  2# happyReduction_12+happyReduction_12 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwPrimitive happy_var_1) -> +	happyIn8+		 (TokKeyword KwPrimitive happy_var_1+	)}++happyReduce_13 = happySpecReduce_1  2# happyReduction_13+happyReduction_13 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwOpen happy_var_1) -> +	happyIn8+		 (TokKeyword KwOpen happy_var_1+	)}++happyReduce_14 = happySpecReduce_1  2# happyReduction_14+happyReduction_14 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwImport happy_var_1) -> +	happyIn8+		 (TokKeyword KwImport happy_var_1+	)}++happyReduce_15 = happySpecReduce_1  2# happyReduction_15+happyReduction_15 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwUsing happy_var_1) -> +	happyIn8+		 (TokKeyword KwUsing happy_var_1+	)}++happyReduce_16 = happySpecReduce_1  2# happyReduction_16+happyReduction_16 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwHiding happy_var_1) -> +	happyIn8+		 (TokKeyword KwHiding happy_var_1+	)}++happyReduce_17 = happySpecReduce_1  2# happyReduction_17+happyReduction_17 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwRenaming happy_var_1) -> +	happyIn8+		 (TokKeyword KwRenaming happy_var_1+	)}++happyReduce_18 = happySpecReduce_1  2# happyReduction_18+happyReduction_18 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwTo happy_var_1) -> +	happyIn8+		 (TokKeyword KwTo happy_var_1+	)}++happyReduce_19 = happySpecReduce_1  2# happyReduction_19+happyReduction_19 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwPublic happy_var_1) -> +	happyIn8+		 (TokKeyword KwPublic happy_var_1+	)}++happyReduce_20 = happySpecReduce_1  2# happyReduction_20+happyReduction_20 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwModule happy_var_1) -> +	happyIn8+		 (TokKeyword KwModule happy_var_1+	)}++happyReduce_21 = happySpecReduce_1  2# happyReduction_21+happyReduction_21 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwData happy_var_1) -> +	happyIn8+		 (TokKeyword KwData happy_var_1+	)}++happyReduce_22 = happySpecReduce_1  2# happyReduction_22+happyReduction_22 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwCoData happy_var_1) -> +	happyIn8+		 (TokKeyword KwCoData happy_var_1+	)}++happyReduce_23 = happySpecReduce_1  2# happyReduction_23+happyReduction_23 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwRecord happy_var_1) -> +	happyIn8+		 (TokKeyword KwRecord happy_var_1+	)}++happyReduce_24 = happySpecReduce_1  2# happyReduction_24+happyReduction_24 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwConstructor happy_var_1) -> +	happyIn8+		 (TokKeyword KwConstructor happy_var_1+	)}++happyReduce_25 = happySpecReduce_1  2# happyReduction_25+happyReduction_25 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwField happy_var_1) -> +	happyIn8+		 (TokKeyword KwField happy_var_1+	)}++happyReduce_26 = happySpecReduce_1  2# happyReduction_26+happyReduction_26 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwInfix happy_var_1) -> +	happyIn8+		 (TokKeyword KwInfix happy_var_1+	)}++happyReduce_27 = happySpecReduce_1  2# happyReduction_27+happyReduction_27 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwInfixL happy_var_1) -> +	happyIn8+		 (TokKeyword KwInfixL happy_var_1+	)}++happyReduce_28 = happySpecReduce_1  2# happyReduction_28+happyReduction_28 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwInfixR happy_var_1) -> +	happyIn8+		 (TokKeyword KwInfixR happy_var_1+	)}++happyReduce_29 = happySpecReduce_1  2# happyReduction_29+happyReduction_29 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwMutual happy_var_1) -> +	happyIn8+		 (TokKeyword KwMutual happy_var_1+	)}++happyReduce_30 = happySpecReduce_1  2# happyReduction_30+happyReduction_30 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwAbstract happy_var_1) -> +	happyIn8+		 (TokKeyword KwAbstract happy_var_1+	)}++happyReduce_31 = happySpecReduce_1  2# happyReduction_31+happyReduction_31 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwPrivate happy_var_1) -> +	happyIn8+		 (TokKeyword KwPrivate happy_var_1+	)}++happyReduce_32 = happySpecReduce_1  2# happyReduction_32+happyReduction_32 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwProp happy_var_1) -> +	happyIn8+		 (TokKeyword KwProp happy_var_1+	)}++happyReduce_33 = happySpecReduce_1  2# happyReduction_33+happyReduction_33 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwSet happy_var_1) -> +	happyIn8+		 (TokKeyword KwSet happy_var_1+	)}++happyReduce_34 = happySpecReduce_1  2# happyReduction_34+happyReduction_34 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwForall happy_var_1) -> +	happyIn8+		 (TokKeyword KwForall happy_var_1+	)}++happyReduce_35 = happySpecReduce_1  2# happyReduction_35+happyReduction_35 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwSyntax happy_var_1) -> +	happyIn8+		 (TokKeyword KwSyntax happy_var_1+	)}++happyReduce_36 = happySpecReduce_1  2# happyReduction_36+happyReduction_36 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwOPTIONS happy_var_1) -> +	happyIn8+		 (TokKeyword KwOPTIONS happy_var_1+	)}++happyReduce_37 = happySpecReduce_1  2# happyReduction_37+happyReduction_37 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwBUILTIN happy_var_1) -> +	happyIn8+		 (TokKeyword KwBUILTIN happy_var_1+	)}++happyReduce_38 = happySpecReduce_1  2# happyReduction_38+happyReduction_38 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwIMPORT happy_var_1) -> +	happyIn8+		 (TokKeyword KwIMPORT happy_var_1+	)}++happyReduce_39 = happySpecReduce_1  2# happyReduction_39+happyReduction_39 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwCOMPILED happy_var_1) -> +	happyIn8+		 (TokKeyword KwCOMPILED happy_var_1+	)}++happyReduce_40 = happySpecReduce_1  2# happyReduction_40+happyReduction_40 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwCOMPILED_DATA happy_var_1) -> +	happyIn8+		 (TokKeyword KwCOMPILED_DATA happy_var_1+	)}++happyReduce_41 = happySpecReduce_1  2# happyReduction_41+happyReduction_41 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwCOMPILED_TYPE happy_var_1) -> +	happyIn8+		 (TokKeyword KwCOMPILED_TYPE happy_var_1+	)}++happyReduce_42 = happySpecReduce_1  2# happyReduction_42+happyReduction_42 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwCOMPILED_EPIC happy_var_1) -> +	happyIn8+		 (TokKeyword KwCOMPILED_EPIC happy_var_1+	)}++happyReduce_43 = happySpecReduce_1  2# happyReduction_43+happyReduction_43 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwCOMPILED_JS happy_var_1) -> +	happyIn8+		 (TokKeyword KwCOMPILED_JS happy_var_1+	)}++happyReduce_44 = happySpecReduce_1  2# happyReduction_44+happyReduction_44 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwSTATIC happy_var_1) -> +	happyIn8+		 (TokKeyword KwSTATIC happy_var_1+	)}++happyReduce_45 = happySpecReduce_1  2# happyReduction_45+happyReduction_45 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwIMPOSSIBLE happy_var_1) -> +	happyIn8+		 (TokKeyword KwIMPOSSIBLE happy_var_1+	)}++happyReduce_46 = happySpecReduce_1  2# happyReduction_46+happyReduction_46 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwETA happy_var_1) -> +	happyIn8+		 (TokKeyword KwETA happy_var_1+	)}++happyReduce_47 = happySpecReduce_1  2# happyReduction_47+happyReduction_47 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwQuoteGoal happy_var_1) -> +	happyIn8+		 (TokKeyword KwQuoteGoal happy_var_1+	)}++happyReduce_48 = happySpecReduce_1  2# happyReduction_48+happyReduction_48 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwQuote happy_var_1) -> +	happyIn8+		 (TokKeyword KwQuote happy_var_1+	)}++happyReduce_49 = happySpecReduce_1  2# happyReduction_49+happyReduction_49 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwQuoteTerm happy_var_1) -> +	happyIn8+		 (TokKeyword KwQuoteTerm happy_var_1+	)}++happyReduce_50 = happySpecReduce_1  2# happyReduction_50+happyReduction_50 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwUnquote happy_var_1) -> +	happyIn8+		 (TokKeyword KwUnquote happy_var_1+	)}++happyReduce_51 = happySpecReduce_1  2# happyReduction_51+happyReduction_51 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSetN happy_var_1) -> +	happyIn8+		 (TokSetN happy_var_1+	)}++happyReduce_52 = happySpecReduce_1  2# happyReduction_52+happyReduction_52 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokTeX happy_var_1) -> +	happyIn8+		 (TokTeX happy_var_1+	)}++happyReduce_53 = happySpecReduce_1  2# happyReduction_53+happyReduction_53 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokComment happy_var_1) -> +	happyIn8+		 (TokComment happy_var_1+	)}++happyReduce_54 = happySpecReduce_1  2# happyReduction_54+happyReduction_54 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymEllipsis happy_var_1) -> +	happyIn8+		 (TokSymbol SymEllipsis happy_var_1+	)}++happyReduce_55 = happySpecReduce_1  2# happyReduction_55+happyReduction_55 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymDotDot happy_var_1) -> +	happyIn8+		 (TokSymbol SymDotDot happy_var_1+	)}++happyReduce_56 = happySpecReduce_1  2# happyReduction_56+happyReduction_56 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymDot happy_var_1) -> +	happyIn8+		 (TokSymbol SymDot happy_var_1+	)}++happyReduce_57 = happySpecReduce_1  2# happyReduction_57+happyReduction_57 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymSemi happy_var_1) -> +	happyIn8+		 (TokSymbol SymSemi happy_var_1+	)}++happyReduce_58 = happySpecReduce_1  2# happyReduction_58+happyReduction_58 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymColon happy_var_1) -> +	happyIn8+		 (TokSymbol SymColon happy_var_1+	)}++happyReduce_59 = happySpecReduce_1  2# happyReduction_59+happyReduction_59 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymEqual happy_var_1) -> +	happyIn8+		 (TokSymbol SymEqual happy_var_1+	)}++happyReduce_60 = happySpecReduce_1  2# happyReduction_60+happyReduction_60 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymUnderscore happy_var_1) -> +	happyIn8+		 (TokSymbol SymUnderscore happy_var_1+	)}++happyReduce_61 = happySpecReduce_1  2# happyReduction_61+happyReduction_61 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymQuestionMark happy_var_1) -> +	happyIn8+		 (TokSymbol SymQuestionMark happy_var_1+	)}++happyReduce_62 = happySpecReduce_1  2# happyReduction_62+happyReduction_62 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymArrow happy_var_1) -> +	happyIn8+		 (TokSymbol SymArrow happy_var_1+	)}++happyReduce_63 = happySpecReduce_1  2# happyReduction_63+happyReduction_63 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymLambda happy_var_1) -> +	happyIn8+		 (TokSymbol SymLambda happy_var_1+	)}++happyReduce_64 = happySpecReduce_1  2# happyReduction_64+happyReduction_64 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymAs happy_var_1) -> +	happyIn8+		 (TokSymbol SymAs happy_var_1+	)}++happyReduce_65 = happySpecReduce_1  2# happyReduction_65+happyReduction_65 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymBar happy_var_1) -> +	happyIn8+		 (TokSymbol SymBar happy_var_1+	)}++happyReduce_66 = happySpecReduce_1  2# happyReduction_66+happyReduction_66 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymOpenParen happy_var_1) -> +	happyIn8+		 (TokSymbol SymOpenParen happy_var_1+	)}++happyReduce_67 = happySpecReduce_1  2# happyReduction_67+happyReduction_67 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymCloseParen happy_var_1) -> +	happyIn8+		 (TokSymbol SymCloseParen happy_var_1+	)}++happyReduce_68 = happySpecReduce_1  2# happyReduction_68+happyReduction_68 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymDoubleOpenBrace happy_var_1) -> +	happyIn8+		 (TokSymbol SymDoubleOpenBrace happy_var_1+	)}++happyReduce_69 = happySpecReduce_1  2# happyReduction_69+happyReduction_69 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymDoubleCloseBrace happy_var_1) -> +	happyIn8+		 (TokSymbol SymDoubleCloseBrace happy_var_1+	)}++happyReduce_70 = happySpecReduce_1  2# happyReduction_70+happyReduction_70 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymOpenBrace happy_var_1) -> +	happyIn8+		 (TokSymbol SymOpenBrace happy_var_1+	)}++happyReduce_71 = happySpecReduce_1  2# happyReduction_71+happyReduction_71 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymCloseBrace happy_var_1) -> +	happyIn8+		 (TokSymbol SymCloseBrace happy_var_1+	)}++happyReduce_72 = happySpecReduce_1  2# happyReduction_72+happyReduction_72 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymOpenVirtualBrace happy_var_1) -> +	happyIn8+		 (TokSymbol SymOpenVirtualBrace happy_var_1+	)}++happyReduce_73 = happySpecReduce_1  2# happyReduction_73+happyReduction_73 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymCloseVirtualBrace happy_var_1) -> +	happyIn8+		 (TokSymbol SymCloseVirtualBrace happy_var_1+	)}++happyReduce_74 = happySpecReduce_1  2# happyReduction_74+happyReduction_74 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymVirtualSemi happy_var_1) -> +	happyIn8+		 (TokSymbol SymVirtualSemi happy_var_1+	)}++happyReduce_75 = happySpecReduce_1  2# happyReduction_75+happyReduction_75 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> +	happyIn8+		 (TokSymbol SymOpenPragma happy_var_1+	)}++happyReduce_76 = happySpecReduce_1  2# happyReduction_76+happyReduction_76 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymClosePragma happy_var_1) -> +	happyIn8+		 (TokSymbol SymClosePragma happy_var_1+	)}++happyReduce_77 = happySpecReduce_1  2# happyReduction_77+happyReduction_77 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokId happy_var_1) -> +	happyIn8+		 (TokId happy_var_1+	)}++happyReduce_78 = happySpecReduce_1  2# happyReduction_78+happyReduction_78 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokQId happy_var_1) -> +	happyIn8+		 (TokQId happy_var_1+	)}++happyReduce_79 = happySpecReduce_1  2# happyReduction_79+happyReduction_79 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokString happy_var_1) -> +	happyIn8+		 (TokString happy_var_1+	)}++happyReduce_80 = happySpecReduce_1  2# happyReduction_80+happyReduction_80 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokLiteral happy_var_1) -> +	happyIn8+		 (TokLiteral happy_var_1+	)}++happyReduce_81 = happySpecReduce_1  3# happyReduction_81+happyReduction_81 happy_x_1+	 =  case happyOut10 happy_x_1 of { happy_var_1 -> +	happyIn9+		 (happy_var_1+	)}++happyReduce_82 = happySpecReduce_1  4# happyReduction_82+happyReduction_82 happy_x_1+	 =  case happyOut106 happy_x_1 of { happy_var_1 -> +	happyIn10+		 (([], happy_var_1)+	)}++happyReduce_83 = happySpecReduce_2  4# happyReduction_83+happyReduction_83 happy_x_2+	happy_x_1+	 =  case happyOut109 happy_x_1 of { happy_var_1 -> +	case happyOut10 happy_x_2 of { happy_var_2 -> +	happyIn10+		 (let (ps,m) = happy_var_2 in (happy_var_1 : ps, m)+	)}}++happyReduce_84 = happySpecReduce_1  5# happyReduction_84+happyReduction_84 happy_x_1+	 =  happyIn11+		 (()+	)++happyReduce_85 = happyMonadReduce 1# 5# happyReduction_85+happyReduction_85 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (( popContext)+	) (\r -> happyReturn (happyIn11 r))++happyReduce_86 = happySpecReduce_1  6# happyReduction_86+happyReduction_86 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymSemi happy_var_1) -> +	happyIn12+		 (happy_var_1+	)}++happyReduce_87 = happySpecReduce_1  6# happyReduction_87+happyReduction_87 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymVirtualSemi happy_var_1) -> +	happyIn12+		 (happy_var_1+	)}++happyReduce_88 = happyMonadReduce 0# 7# happyReduction_88+happyReduction_88 (happyRest) tk+	 = happyThen (( pushLexState imp_dir)+	) (\r -> happyReturn (happyIn13 r))++happyReduce_89 = happyMonadReduce 1# 8# happyReduction_89+happyReduction_89 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOutTok happy_x_1 of { (TokLiteral happy_var_1) -> +	( case happy_var_1 of {+		     LitInt _ n	-> return n;+		     _		-> fail $ "Expected integer"+		   })}+	) (\r -> happyReturn (happyIn14 r))++happyReduce_90 = happyMonadReduce 1# 9# happyReduction_90+happyReduction_90 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOutTok happy_x_1 of { (TokId happy_var_1) -> +	( mkName happy_var_1)}+	) (\r -> happyReturn (happyIn15 r))++happyReduce_91 = happySpecReduce_2  10# happyReduction_91+happyReduction_91 happy_x_2+	happy_x_1+	 =  case happyOut15 happy_x_1 of { happy_var_1 -> +	case happyOut16 happy_x_2 of { happy_var_2 -> +	happyIn16+		 (happy_var_1 : happy_var_2+	)}}++happyReduce_92 = happySpecReduce_1  10# happyReduction_92+happyReduction_92 happy_x_1+	 =  case happyOut15 happy_x_1 of { happy_var_1 -> +	happyIn16+		 ([happy_var_1]+	)}++happyReduce_93 = happySpecReduce_1  11# happyReduction_93+happyReduction_93 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymDoubleCloseBrace happy_var_1) -> +	happyIn17+		 (getRange happy_var_1+	)}++happyReduce_94 = happyMonadReduce 2# 11# happyReduction_94+happyReduction_94 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOutTok happy_x_1 of { (TokSymbol SymCloseBrace happy_var_1) -> +	case happyOutTok happy_x_2 of { (TokSymbol SymCloseBrace happy_var_2) -> +	(+      if posPos (fromJust (rEnd (getRange happy_var_2))) -+	 posPos (fromJust (rStart (getRange happy_var_1))) > 2+      then parseErrorAt (fromJust (rStart (getRange happy_var_2)))+	 "Expecting '}}', found separated '}'s."+      else return $ fuseRange (getRange happy_var_1) (getRange (happy_var_2)))}}+	) (\r -> happyReturn (happyIn17 r))++happyReduce_95 = happySpecReduce_2  12# happyReduction_95+happyReduction_95 happy_x_2+	happy_x_1+	 =  case happyOut15 happy_x_2 of { happy_var_2 -> +	happyIn18+		 (Arg NotHidden Irrelevant happy_var_2+	)}++happyReduce_96 = happySpecReduce_1  12# happyReduction_96+happyReduction_96 happy_x_1+	 =  case happyOut15 happy_x_1 of { happy_var_1 -> +	happyIn18+		 (defaultArg happy_var_1+	)}++happyReduce_97 = happySpecReduce_2  13# happyReduction_97+happyReduction_97 happy_x_2+	happy_x_1+	 =  case happyOut18 happy_x_1 of { happy_var_1 -> +	case happyOut19 happy_x_2 of { happy_var_2 -> +	happyIn19+		 (happy_var_1 : happy_var_2+	)}}++happyReduce_98 = happySpecReduce_1  13# happyReduction_98+happyReduction_98 happy_x_1+	 =  case happyOut18 happy_x_1 of { happy_var_1 -> +	happyIn19+		 ([happy_var_1]+	)}++happyReduce_99 = happySpecReduce_2  14# happyReduction_99+happyReduction_99 happy_x_2+	happy_x_1+	 =  case happyOut18 happy_x_1 of { happy_var_1 -> +	case happyOut20 happy_x_2 of { happy_var_2 -> +	happyIn20+		 (happy_var_1 : happy_var_2+	)}}++happyReduce_100 = happySpecReduce_1  14# happyReduction_100+happyReduction_100 happy_x_1+	 =  case happyOut18 happy_x_1 of { happy_var_1 -> +	happyIn20+		 ([happy_var_1]+	)}++happyReduce_101 = happyReduce 4# 14# happyReduction_101+happyReduction_101 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut19 happy_x_2 of { happy_var_2 -> +	case happyOut20 happy_x_4 of { happy_var_4 -> +	happyIn20+		 (map makeInstance happy_var_2 ++ happy_var_4+	) `HappyStk` happyRest}}++happyReduce_102 = happySpecReduce_3  14# happyReduction_102+happyReduction_102 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut19 happy_x_2 of { happy_var_2 -> +	happyIn20+		 (map makeInstance happy_var_2+	)}++happyReduce_103 = happyReduce 4# 14# happyReduction_103+happyReduction_103 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut19 happy_x_2 of { happy_var_2 -> +	case happyOut20 happy_x_4 of { happy_var_4 -> +	happyIn20+		 (map hide happy_var_2 ++ happy_var_4+	) `HappyStk` happyRest}}++happyReduce_104 = happySpecReduce_3  14# happyReduction_104+happyReduction_104 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut19 happy_x_2 of { happy_var_2 -> +	happyIn20+		 (map hide happy_var_2+	)}++happyReduce_105 = happyReduce 5# 14# happyReduction_105+happyReduction_105 (happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut16 happy_x_3 of { happy_var_3 -> +	case happyOut20 happy_x_5 of { happy_var_5 -> +	happyIn20+		 (map (Arg Hidden Irrelevant) happy_var_3 ++ happy_var_5+	) `HappyStk` happyRest}}++happyReduce_106 = happyReduce 4# 14# happyReduction_106+happyReduction_106 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut16 happy_x_3 of { happy_var_3 -> +	happyIn20+		 (map (Arg Hidden Irrelevant) happy_var_3+	) `HappyStk` happyRest}++happyReduce_107 = happyReduce 5# 14# happyReduction_107+happyReduction_107 (happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut16 happy_x_3 of { happy_var_3 -> +	case happyOut20 happy_x_5 of { happy_var_5 -> +	happyIn20+		 (map (Arg Instance Irrelevant) happy_var_3 ++ happy_var_5+	) `HappyStk` happyRest}}++happyReduce_108 = happyReduce 4# 14# happyReduction_108+happyReduction_108 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut16 happy_x_3 of { happy_var_3 -> +	happyIn20+		 (map (Arg Instance Irrelevant) happy_var_3+	) `HappyStk` happyRest}++happyReduce_109 = happyReduce 5# 14# happyReduction_109+happyReduction_109 (happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut16 happy_x_3 of { happy_var_3 -> +	case happyOut20 happy_x_5 of { happy_var_5 -> +	happyIn20+		 (map (Arg Hidden NonStrict) happy_var_3 ++ happy_var_5+	) `HappyStk` happyRest}}++happyReduce_110 = happyReduce 4# 14# happyReduction_110+happyReduction_110 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut16 happy_x_3 of { happy_var_3 -> +	happyIn20+		 (map (Arg Hidden NonStrict) happy_var_3+	) `HappyStk` happyRest}++happyReduce_111 = happyReduce 5# 14# happyReduction_111+happyReduction_111 (happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut16 happy_x_3 of { happy_var_3 -> +	case happyOut20 happy_x_5 of { happy_var_5 -> +	happyIn20+		 (map (Arg Instance NonStrict) happy_var_3 ++ happy_var_5+	) `HappyStk` happyRest}}++happyReduce_112 = happyReduce 4# 14# happyReduction_112+happyReduction_112 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut16 happy_x_3 of { happy_var_3 -> +	happyIn20+		 (map (Arg Instance NonStrict) happy_var_3+	) `HappyStk` happyRest}++happyReduce_113 = happyMonadReduce 1# 15# happyReduction_113+happyReduction_113 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOutTok happy_x_1 of { (TokQId happy_var_1) -> +	( mkQName happy_var_1)}+	) (\r -> happyReturn (happyIn21 r))++happyReduce_114 = happySpecReduce_1  15# happyReduction_114+happyReduction_114 happy_x_1+	 =  case happyOut15 happy_x_1 of { happy_var_1 -> +	happyIn21+		 (QName happy_var_1+	)}++happyReduce_115 = happySpecReduce_1  16# happyReduction_115+happyReduction_115 happy_x_1+	 =  case happyOut21 happy_x_1 of { happy_var_1 -> +	happyIn22+		 (happy_var_1+	)}++happyReduce_116 = happySpecReduce_1  17# happyReduction_116+happyReduction_116 happy_x_1+	 =  case happyOut15 happy_x_1 of { happy_var_1 -> +	happyIn23+		 (happy_var_1+	)}++happyReduce_117 = happySpecReduce_1  17# happyReduction_117+happyReduction_117 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymUnderscore happy_var_1) -> +	happyIn23+		 (Name (getRange happy_var_1) [Hole]+	)}++happyReduce_118 = happySpecReduce_2  18# happyReduction_118+happyReduction_118 happy_x_2+	happy_x_1+	 =  case happyOut23 happy_x_1 of { happy_var_1 -> +	case happyOut24 happy_x_2 of { happy_var_2 -> +	happyIn24+		 (happy_var_1 : happy_var_2+	)}}++happyReduce_119 = happySpecReduce_1  18# happyReduction_119+happyReduction_119 happy_x_1+	 =  case happyOut23 happy_x_1 of { happy_var_1 -> +	happyIn24+		 ([happy_var_1]+	)}++happyReduce_120 = happySpecReduce_1  19# happyReduction_120+happyReduction_120 happy_x_1+	 =  case happyOut26 happy_x_1 of { happy_var_1 -> +	happyIn25+		 (case happy_var_1 of+      Left ns -> ns+      Right _ -> fail $ "expected sequence of bound identifiers, not absurd pattern"+	)}++happyReduce_121 = happyMonadReduce 1# 20# happyReduction_121+happyReduction_121 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut32 happy_x_1 of { happy_var_1 -> +	(+    let getName (Ident (QName x)) = Just x+	getName (Underscore r _)  = Just (Name r [Hole])+	getName _		  = Nothing++        containsAbsurd (Absurd _) = True+        containsAbsurd (HiddenArg _ (Named _ e)) = containsAbsurd e+        containsAbsurd (InstanceArg _ (Named _ e)) = containsAbsurd e+        containsAbsurd (Paren _ expr)    = containsAbsurd expr+        containsAbsurd (RawApp _ exprs)    = any containsAbsurd exprs+        containsAbsurd _          = False+    in+    if isJust $ find containsAbsurd happy_var_1 then return $ Right happy_var_1 else+    case partition isJust $ map getName happy_var_1 of+	(good, []) -> return $ Left $ map fromJust good+	_	   -> fail $ "expected sequence of bound identifiers")}+	) (\r -> happyReturn (happyIn26 r))++happyReduce_122 = happySpecReduce_0  21# happyReduction_122+happyReduction_122  =  happyIn27+		 ([]+	)++happyReduce_123 = happySpecReduce_2  21# happyReduction_123+happyReduction_123 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokString happy_var_1) -> +	case happyOut27 happy_x_2 of { happy_var_2 -> +	happyIn27+		 (snd happy_var_1 : happy_var_2+	)}}++happyReduce_124 = happyMonadReduce 1# 22# happyReduction_124+happyReduction_124 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOutTok happy_x_1 of { (TokString happy_var_1) -> +	( fmap QName (mkName happy_var_1))}+	) (\r -> happyReturn (happyIn28 r))++happyReduce_125 = happySpecReduce_2  23# happyReduction_125+happyReduction_125 happy_x_2+	happy_x_1+	 =  case happyOut41 happy_x_1 of { happy_var_1 -> +	case happyOut29 happy_x_2 of { happy_var_2 -> +	happyIn29+		 (Pi happy_var_1 happy_var_2+	)}}++happyReduce_126 = happySpecReduce_3  23# happyReduction_126+happyReduction_126 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut54 happy_x_2 of { happy_var_2 -> +	case happyOut29 happy_x_3 of { happy_var_3 -> +	happyIn29+		 (forallPi happy_var_2 happy_var_3+	)}}++happyReduce_127 = happySpecReduce_3  23# happyReduction_127+happyReduction_127 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut34 happy_x_1 of { happy_var_1 -> +	case happyOut29 happy_x_3 of { happy_var_3 -> +	happyIn29+		 (Fun (fuseRange happy_var_1 happy_var_3) (RawApp (getRange happy_var_1) happy_var_1) happy_var_3+	)}}++happyReduce_128 = happySpecReduce_1  23# happyReduction_128+happyReduction_128 happy_x_1+	 =  case happyOut30 happy_x_1 of { happy_var_1 -> +	happyIn29+		 (happy_var_1+	)}++happyReduce_129 = happyMonadReduce 1# 24# happyReduction_129+happyReduction_129 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut31 happy_x_1 of { happy_var_1 -> +	( case happy_var_1 of+		      { [e]    -> return e+		      ; e : es -> return $ WithApp (fuseRange e es) e es+		      ; []     -> fail "impossible: empty with expressions"+		      })}+	) (\r -> happyReturn (happyIn30 r))++happyReduce_130 = happySpecReduce_3  25# happyReduction_130+happyReduction_130 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut34 happy_x_1 of { happy_var_1 -> +	case happyOut31 happy_x_3 of { happy_var_3 -> +	happyIn31+		 (RawApp (getRange happy_var_1) happy_var_1 :  happy_var_3+	)}}++happyReduce_131 = happySpecReduce_1  25# happyReduction_131+happyReduction_131 happy_x_1+	 =  case happyOut32 happy_x_1 of { happy_var_1 -> +	happyIn31+		 ([RawApp (getRange happy_var_1) happy_var_1]+	)}++happyReduce_132 = happySpecReduce_1  26# happyReduction_132+happyReduction_132 happy_x_1+	 =  case happyOut33 happy_x_1 of { happy_var_1 -> +	happyIn32+		 ([happy_var_1]+	)}++happyReduce_133 = happySpecReduce_2  26# happyReduction_133+happyReduction_133 happy_x_2+	happy_x_1+	 =  case happyOut37 happy_x_1 of { happy_var_1 -> +	case happyOut32 happy_x_2 of { happy_var_2 -> +	happyIn32+		 (happy_var_1 : happy_var_2+	)}}++happyReduce_134 = happySpecReduce_3  27# happyReduction_134+happyReduction_134 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymLambda happy_var_1) -> +	case happyOut46 happy_x_2 of { happy_var_2 -> +	case happyOut29 happy_x_3 of { happy_var_3 -> +	happyIn33+		 (Lam (fuseRange happy_var_1 happy_var_3) happy_var_2 happy_var_3+	)}}}++happyReduce_135 = happyReduce 4# 27# happyReduction_135+happyReduction_135 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { (TokSymbol SymLambda happy_var_1) -> +	case happyOutTok happy_x_2 of { (TokSymbol SymOpenBrace happy_var_2) -> +	case happyOut53 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (TokSymbol SymCloseBrace happy_var_4) -> +	happyIn33+		 (ExtendedLam (fuseRange happy_var_1 (fuseRange happy_var_2 happy_var_4)) (reverse happy_var_3)+	) `HappyStk` happyRest}}}}++happyReduce_136 = happyMonadReduce 2# 27# happyReduction_136+happyReduction_136 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOutTok happy_x_1 of { (TokSymbol SymLambda happy_var_1) -> +	case happyOut47 happy_x_2 of { happy_var_2 -> +	( case happy_var_2 of+                                       Left (bs, h) -> if null bs then return $ AbsurdLam r h else+                                                       return $ Lam r bs (AbsurdLam r h)+                                                         where r = fuseRange happy_var_1 bs+    				       Right es -> do -- it is of the form @\ { p1 ... () }@+                                                     p <- exprToLHS (RawApp (getRange es) es);+                                                     return $ ExtendedLam (fuseRange happy_var_1 es)+                                                                     [(p [] [], AbsurdRHS, NoWhere)])}}+	) (\r -> happyReturn (happyIn33 r))++happyReduce_137 = happyReduce 4# 27# happyReduction_137+happyReduction_137 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { (TokKeyword KwLet happy_var_1) -> +	case happyOut130 happy_x_2 of { happy_var_2 -> +	case happyOut29 happy_x_4 of { happy_var_4 -> +	happyIn33+		 (Let (fuseRange happy_var_1 happy_var_4) happy_var_2 happy_var_4+	) `HappyStk` happyRest}}}++happyReduce_138 = happySpecReduce_1  27# happyReduction_138+happyReduction_138 happy_x_1+	 =  case happyOut37 happy_x_1 of { happy_var_1 -> +	happyIn33+		 (happy_var_1+	)}++happyReduce_139 = happyReduce 4# 27# happyReduction_139+happyReduction_139 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { (TokKeyword KwQuoteGoal happy_var_1) -> +	case happyOut15 happy_x_2 of { happy_var_2 -> +	case happyOut29 happy_x_4 of { happy_var_4 -> +	happyIn33+		 (QuoteGoal (getRange (happy_var_1,happy_var_4)) happy_var_2 happy_var_4+	) `HappyStk` happyRest}}}++happyReduce_140 = happySpecReduce_1  28# happyReduction_140+happyReduction_140 happy_x_1+	 =  case happyOut37 happy_x_1 of { happy_var_1 -> +	happyIn34+		 ([happy_var_1]+	)}++happyReduce_141 = happySpecReduce_2  28# happyReduction_141+happyReduction_141 happy_x_2+	happy_x_1+	 =  case happyOut37 happy_x_1 of { happy_var_1 -> +	case happyOut34 happy_x_2 of { happy_var_2 -> +	happyIn34+		 (happy_var_1 : happy_var_2+	)}}++happyReduce_142 = happySpecReduce_3  29# happyReduction_142+happyReduction_142 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymOpenBrace happy_var_1) -> +	case happyOut29 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (TokSymbol SymCloseBrace happy_var_3) -> +	happyIn35+		 (HiddenArg (fuseRange happy_var_1 happy_var_3) (unnamed happy_var_2)+	)}}}++happyReduce_143 = happyReduce 5# 29# happyReduction_143+happyReduction_143 (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 { (TokSymbol SymOpenBrace happy_var_1) -> +	case happyOut15 happy_x_2 of { happy_var_2 -> +	case happyOut29 happy_x_4 of { happy_var_4 -> +	case happyOutTok happy_x_5 of { (TokSymbol SymCloseBrace happy_var_5) -> +	happyIn35+		 (HiddenArg (fuseRange happy_var_1 happy_var_5) (named (show happy_var_2) happy_var_4)+	) `HappyStk` happyRest}}}}++happyReduce_144 = happySpecReduce_2  29# happyReduction_144+happyReduction_144 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymOpenBrace happy_var_1) -> +	case happyOutTok happy_x_2 of { (TokSymbol SymCloseBrace happy_var_2) -> +	happyIn35+		 (let r = fuseRange happy_var_1 happy_var_2 in HiddenArg r $ unnamed $ Absurd r+	)}}++happyReduce_145 = happySpecReduce_1  30# happyReduction_145+happyReduction_145 happy_x_1+	 =  case happyOut21 happy_x_1 of { happy_var_1 -> +	happyIn36+		 (Ident happy_var_1+	)}++happyReduce_146 = happySpecReduce_1  30# happyReduction_146+happyReduction_146 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokLiteral happy_var_1) -> +	happyIn36+		 (Lit happy_var_1+	)}++happyReduce_147 = happySpecReduce_1  30# happyReduction_147+happyReduction_147 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymQuestionMark happy_var_1) -> +	happyIn36+		 (QuestionMark (getRange happy_var_1) Nothing+	)}++happyReduce_148 = happySpecReduce_1  30# happyReduction_148+happyReduction_148 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymUnderscore happy_var_1) -> +	happyIn36+		 (Underscore (getRange happy_var_1) Nothing+	)}++happyReduce_149 = happySpecReduce_1  30# happyReduction_149+happyReduction_149 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwProp happy_var_1) -> +	happyIn36+		 (Prop (getRange happy_var_1)+	)}++happyReduce_150 = happySpecReduce_1  30# happyReduction_150+happyReduction_150 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwSet happy_var_1) -> +	happyIn36+		 (Set (getRange happy_var_1)+	)}++happyReduce_151 = happySpecReduce_1  30# happyReduction_151+happyReduction_151 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwQuote happy_var_1) -> +	happyIn36+		 (Quote (getRange happy_var_1)+	)}++happyReduce_152 = happySpecReduce_1  30# happyReduction_152+happyReduction_152 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwQuoteTerm happy_var_1) -> +	happyIn36+		 (QuoteTerm (getRange happy_var_1)+	)}++happyReduce_153 = happySpecReduce_1  30# happyReduction_153+happyReduction_153 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwUnquote happy_var_1) -> +	happyIn36+		 (Unquote (getRange happy_var_1)+	)}++happyReduce_154 = happySpecReduce_1  30# happyReduction_154+happyReduction_154 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSetN happy_var_1) -> +	happyIn36+		 (SetN (getRange (fst happy_var_1)) (snd happy_var_1)+	)}++happyReduce_155 = happySpecReduce_3  30# happyReduction_155+happyReduction_155 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymDoubleOpenBrace happy_var_1) -> +	case happyOut29 happy_x_2 of { happy_var_2 -> +	case happyOut17 happy_x_3 of { happy_var_3 -> +	happyIn36+		 (InstanceArg (fuseRange happy_var_1 happy_var_3) (unnamed happy_var_2)+	)}}}++happyReduce_156 = happyReduce 5# 30# happyReduction_156+happyReduction_156 (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 { (TokSymbol SymDoubleOpenBrace happy_var_1) -> +	case happyOut15 happy_x_2 of { happy_var_2 -> +	case happyOut29 happy_x_4 of { happy_var_4 -> +	case happyOut17 happy_x_5 of { happy_var_5 -> +	happyIn36+		 (InstanceArg (fuseRange happy_var_1 happy_var_5) (named (show happy_var_2) happy_var_4)+	) `HappyStk` happyRest}}}}++happyReduce_157 = happySpecReduce_3  30# happyReduction_157+happyReduction_157 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymOpenParen happy_var_1) -> +	case happyOut29 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (TokSymbol SymCloseParen happy_var_3) -> +	happyIn36+		 (Paren (fuseRange happy_var_1 happy_var_3) happy_var_2+	)}}}++happyReduce_158 = happySpecReduce_2  30# happyReduction_158+happyReduction_158 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymOpenParen happy_var_1) -> +	case happyOutTok happy_x_2 of { (TokSymbol SymCloseParen happy_var_2) -> +	happyIn36+		 (Absurd (fuseRange happy_var_1 happy_var_2)+	)}}++happyReduce_159 = happySpecReduce_2  30# happyReduction_159+happyReduction_159 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymDoubleOpenBrace happy_var_1) -> +	case happyOut17 happy_x_2 of { happy_var_2 -> +	happyIn36+		 (let r = fuseRange happy_var_1 happy_var_2 in InstanceArg r $ unnamed $ Absurd r+	)}}++happyReduce_160 = happySpecReduce_3  30# happyReduction_160+happyReduction_160 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut15 happy_x_1 of { happy_var_1 -> +	case happyOut37 happy_x_3 of { happy_var_3 -> +	happyIn36+		 (As (fuseRange happy_var_1 happy_var_3) happy_var_1 happy_var_3+	)}}++happyReduce_161 = happySpecReduce_2  30# happyReduction_161+happyReduction_161 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymDot happy_var_1) -> +	case happyOut37 happy_x_2 of { happy_var_2 -> +	happyIn36+		 (Dot (fuseRange happy_var_1 happy_var_2) happy_var_2+	)}}++happyReduce_162 = happyReduce 4# 30# happyReduction_162+happyReduction_162 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { (TokKeyword KwRecord happy_var_1) -> +	case happyOut38 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (TokSymbol SymCloseBrace happy_var_4) -> +	happyIn36+		 (Rec (getRange (happy_var_1,happy_var_4)) happy_var_3+	) `HappyStk` happyRest}}}++happyReduce_163 = happyReduce 5# 30# happyReduction_163+happyReduction_163 (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 { (TokKeyword KwRecord happy_var_1) -> +	case happyOut36 happy_x_2 of { happy_var_2 -> +	case happyOut38 happy_x_4 of { happy_var_4 -> +	case happyOutTok happy_x_5 of { (TokSymbol SymCloseBrace happy_var_5) -> +	happyIn36+		 (RecUpdate (getRange (happy_var_1,happy_var_5)) happy_var_2 happy_var_4+	) `HappyStk` happyRest}}}}++happyReduce_164 = happySpecReduce_1  31# happyReduction_164+happyReduction_164 happy_x_1+	 =  case happyOut35 happy_x_1 of { happy_var_1 -> +	happyIn37+		 (happy_var_1+	)}++happyReduce_165 = happySpecReduce_1  31# happyReduction_165+happyReduction_165 happy_x_1+	 =  case happyOut36 happy_x_1 of { happy_var_1 -> +	happyIn37+		 (happy_var_1+	)}++happyReduce_166 = happySpecReduce_0  32# happyReduction_166+happyReduction_166  =  happyIn38+		 ([]+	)++happyReduce_167 = happySpecReduce_1  32# happyReduction_167+happyReduction_167 happy_x_1+	 =  case happyOut39 happy_x_1 of { happy_var_1 -> +	happyIn38+		 (happy_var_1+	)}++happyReduce_168 = happySpecReduce_1  33# happyReduction_168+happyReduction_168 happy_x_1+	 =  case happyOut40 happy_x_1 of { happy_var_1 -> +	happyIn39+		 ([happy_var_1]+	)}++happyReduce_169 = happySpecReduce_3  33# happyReduction_169+happyReduction_169 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut40 happy_x_1 of { happy_var_1 -> +	case happyOut39 happy_x_3 of { happy_var_3 -> +	happyIn39+		 (happy_var_1 : happy_var_3+	)}}++happyReduce_170 = happySpecReduce_3  34# happyReduction_170+happyReduction_170 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut15 happy_x_1 of { happy_var_1 -> +	case happyOut29 happy_x_3 of { happy_var_3 -> +	happyIn40+		 ((happy_var_1, happy_var_3)+	)}}++happyReduce_171 = happySpecReduce_2  35# happyReduction_171+happyReduction_171 happy_x_2+	happy_x_1+	 =  case happyOut42 happy_x_1 of { happy_var_1 -> +	happyIn41+		 (happy_var_1+	)}++happyReduce_172 = happySpecReduce_1  36# happyReduction_172+happyReduction_172 happy_x_1+	 =  case happyOut43 happy_x_1 of { happy_var_1 -> +	happyIn42+		 ({-TeleBind-} happy_var_1+	)}++happyReduce_173 = happySpecReduce_2  37# happyReduction_173+happyReduction_173 happy_x_2+	happy_x_1+	 =  case happyOut44 happy_x_1 of { happy_var_1 -> +	case happyOut43 happy_x_2 of { happy_var_2 -> +	happyIn43+		 (happy_var_1 : happy_var_2+	)}}++happyReduce_174 = happySpecReduce_1  37# happyReduction_174+happyReduction_174 happy_x_1+	 =  case happyOut44 happy_x_1 of { happy_var_1 -> +	happyIn43+		 ([happy_var_1]+	)}++happyReduce_175 = happyReduce 4# 38# happyReduction_175+happyReduction_175 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_2 of { (TokSymbol SymOpenParen happy_var_2) -> +	case happyOut45 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (TokSymbol SymCloseParen happy_var_4) -> +	happyIn44+		 (TypedBindings (fuseRange happy_var_2 happy_var_4) (Arg NotHidden         Irrelevant happy_var_3)+	) `HappyStk` happyRest}}}++happyReduce_176 = happyReduce 4# 38# happyReduction_176+happyReduction_176 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_2 of { (TokSymbol SymOpenBrace happy_var_2) -> +	case happyOut45 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (TokSymbol SymCloseBrace happy_var_4) -> +	happyIn44+		 (TypedBindings (fuseRange happy_var_2 happy_var_4) (Arg Hidden            Irrelevant happy_var_3)+	) `HappyStk` happyRest}}}++happyReduce_177 = happyReduce 4# 38# happyReduction_177+happyReduction_177 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { (TokSymbol SymDot happy_var_1) -> +	case happyOut45 happy_x_3 of { happy_var_3 -> +	happyIn44+		 (TypedBindings (fuseRange happy_var_1 happy_var_3) (Arg Instance Irrelevant happy_var_3)+	) `HappyStk` happyRest}}++happyReduce_178 = happyReduce 4# 38# happyReduction_178+happyReduction_178 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_2 of { (TokSymbol SymOpenParen happy_var_2) -> +	case happyOut45 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (TokSymbol SymCloseParen happy_var_4) -> +	happyIn44+		 (TypedBindings (fuseRange happy_var_2 happy_var_4) (Arg NotHidden         NonStrict happy_var_3)+	) `HappyStk` happyRest}}}++happyReduce_179 = happyReduce 4# 38# happyReduction_179+happyReduction_179 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_2 of { (TokSymbol SymOpenBrace happy_var_2) -> +	case happyOut45 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (TokSymbol SymCloseBrace happy_var_4) -> +	happyIn44+		 (TypedBindings (fuseRange happy_var_2 happy_var_4) (Arg Hidden            NonStrict happy_var_3)+	) `HappyStk` happyRest}}}++happyReduce_180 = happyReduce 4# 38# happyReduction_180+happyReduction_180 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { (TokSymbol SymDotDot happy_var_1) -> +	case happyOut45 happy_x_3 of { happy_var_3 -> +	happyIn44+		 (TypedBindings (fuseRange happy_var_1 happy_var_3) (Arg Instance NonStrict happy_var_3)+	) `HappyStk` happyRest}}++happyReduce_181 = happySpecReduce_3  38# happyReduction_181+happyReduction_181 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymOpenParen happy_var_1) -> +	case happyOut45 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (TokSymbol SymCloseParen happy_var_3) -> +	happyIn44+		 (TypedBindings (fuseRange happy_var_1 happy_var_3) (Arg NotHidden         Relevant happy_var_2)+	)}}}++happyReduce_182 = happySpecReduce_3  38# happyReduction_182+happyReduction_182 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymDoubleOpenBrace happy_var_1) -> +	case happyOut45 happy_x_2 of { happy_var_2 -> +	case happyOut17 happy_x_3 of { happy_var_3 -> +	happyIn44+		 (TypedBindings (fuseRange happy_var_1 happy_var_3) (Arg Instance Relevant happy_var_2)+	)}}}++happyReduce_183 = happySpecReduce_3  38# happyReduction_183+happyReduction_183 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymOpenBrace happy_var_1) -> +	case happyOut45 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (TokSymbol SymCloseBrace happy_var_3) -> +	happyIn44+		 (TypedBindings (fuseRange happy_var_1 happy_var_3) (Arg Hidden            Relevant happy_var_2)+	)}}}++happyReduce_184 = happySpecReduce_3  39# happyReduction_184+happyReduction_184 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut25 happy_x_1 of { happy_var_1 -> +	case happyOut29 happy_x_3 of { happy_var_3 -> +	happyIn45+		 (TBind (fuseRange happy_var_1 happy_var_3) (map mkBoundName_ happy_var_1) happy_var_3+	)}}++happyReduce_185 = happyMonadReduce 2# 40# happyReduction_185+happyReduction_185 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut48 happy_x_1 of { happy_var_1 -> +	(+      case reverse happy_var_1 of+        Left _ : _ -> parseError "Absurd lambda cannot have a body."+	_ : _      -> return [ b | Right b <- happy_var_1 ]+        []         -> parsePanic "Empty LamBinds")}+	) (\r -> happyReturn (happyIn46 r))++happyReduce_186 = happyMonadReduce 1# 41# happyReduction_186+happyReduction_186 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut49 happy_x_1 of { happy_var_1 -> +	(+    case happy_var_1 of+      Left lb -> case reverse lb of+                   Right _ : _ -> parseError "Missing body for lambda"+                   Left h  : _ -> return $ Left ([ b | Right b <- init lb], h)+                   _           -> parsePanic "Empty LamBindsAbsurd"+      Right es -> return $ Right es)}+	) (\r -> happyReturn (happyIn47 r))++happyReduce_187 = happySpecReduce_2  42# happyReduction_187+happyReduction_187 happy_x_2+	happy_x_1+	 =  case happyOut57 happy_x_1 of { happy_var_1 -> +	case happyOut48 happy_x_2 of { happy_var_2 -> +	happyIn48+		 (map Right happy_var_1 ++ happy_var_2+	)}}++happyReduce_188 = happySpecReduce_2  42# happyReduction_188+happyReduction_188 happy_x_2+	happy_x_1+	 =  case happyOut44 happy_x_1 of { happy_var_1 -> +	case happyOut48 happy_x_2 of { happy_var_2 -> +	happyIn48+		 (Right (DomainFull happy_var_1) : happy_var_2+	)}}++happyReduce_189 = happySpecReduce_1  42# happyReduction_189+happyReduction_189 happy_x_1+	 =  case happyOut57 happy_x_1 of { happy_var_1 -> +	happyIn48+		 (map Right happy_var_1+	)}++happyReduce_190 = happySpecReduce_1  42# happyReduction_190+happyReduction_190 happy_x_1+	 =  case happyOut44 happy_x_1 of { happy_var_1 -> +	happyIn48+		 ([Right $ DomainFull happy_var_1]+	)}++happyReduce_191 = happySpecReduce_2  42# happyReduction_191+happyReduction_191 happy_x_2+	happy_x_1+	 =  happyIn48+		 ([Left NotHidden]+	)++happyReduce_192 = happySpecReduce_2  42# happyReduction_192+happyReduction_192 happy_x_2+	happy_x_1+	 =  happyIn48+		 ([Left Hidden]+	)++happyReduce_193 = happySpecReduce_2  42# happyReduction_193+happyReduction_193 happy_x_2+	happy_x_1+	 =  happyIn48+		 ([Left Instance]+	)++happyReduce_194 = happySpecReduce_2  43# happyReduction_194+happyReduction_194 happy_x_2+	happy_x_1+	 =  case happyOut57 happy_x_1 of { happy_var_1 -> +	case happyOut48 happy_x_2 of { happy_var_2 -> +	happyIn49+		 (Left $ map Right happy_var_1 ++ happy_var_2+	)}}++happyReduce_195 = happySpecReduce_2  43# happyReduction_195+happyReduction_195 happy_x_2+	happy_x_1+	 =  case happyOut44 happy_x_1 of { happy_var_1 -> +	case happyOut48 happy_x_2 of { happy_var_2 -> +	happyIn49+		 (Left $ Right (DomainFull happy_var_1) : happy_var_2+	)}}++happyReduce_196 = happySpecReduce_1  43# happyReduction_196+happyReduction_196 happy_x_1+	 =  case happyOut58 happy_x_1 of { happy_var_1 -> +	happyIn49+		 (case happy_var_1 of+                                    Left lb -> Left $ map Right lb+                                    Right es -> Right es+	)}++happyReduce_197 = happySpecReduce_1  43# happyReduction_197+happyReduction_197 happy_x_1+	 =  case happyOut44 happy_x_1 of { happy_var_1 -> +	happyIn49+		 (Left [Right $ DomainFull happy_var_1]+	)}++happyReduce_198 = happySpecReduce_2  43# happyReduction_198+happyReduction_198 happy_x_2+	happy_x_1+	 =  happyIn49+		 (Left [Left NotHidden]+	)++happyReduce_199 = happySpecReduce_2  43# happyReduction_199+happyReduction_199 happy_x_2+	happy_x_1+	 =  happyIn49+		 (Left [Left Hidden]+	)++happyReduce_200 = happySpecReduce_2  43# happyReduction_200+happyReduction_200 happy_x_2+	happy_x_1+	 =  happyIn49+		 (Left [Left Instance]+	)++happyReduce_201 = happyMonadReduce 3# 44# happyReduction_201+happyReduction_201 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut34 happy_x_1 of { happy_var_1 -> +	case happyOut29 happy_x_3 of { happy_var_3 -> +	( do+      p <- exprToLHS (RawApp (getRange happy_var_1) happy_var_1) ;+      return (p [] [], RHS happy_var_3, NoWhere))}}+	) (\r -> happyReturn (happyIn50 r))++happyReduce_202 = happyMonadReduce 1# 45# happyReduction_202+happyReduction_202 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut32 happy_x_1 of { happy_var_1 -> +	( do+      p <- exprToLHS (RawApp (getRange happy_var_1) happy_var_1);+      return (p [] [], AbsurdRHS, NoWhere))}+	) (\r -> happyReturn (happyIn51 r))++happyReduce_203 = happySpecReduce_1  46# happyReduction_203+happyReduction_203 happy_x_1+	 =  case happyOut50 happy_x_1 of { happy_var_1 -> +	happyIn52+		 (happy_var_1+	)}++happyReduce_204 = happySpecReduce_1  46# happyReduction_204+happyReduction_204 happy_x_1+	 =  case happyOut51 happy_x_1 of { happy_var_1 -> +	happyIn52+		 (happy_var_1+	)}++happyReduce_205 = happySpecReduce_3  47# happyReduction_205+happyReduction_205 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut53 happy_x_1 of { happy_var_1 -> +	case happyOut52 happy_x_3 of { happy_var_3 -> +	happyIn53+		 (happy_var_3 : happy_var_1+	)}}++happyReduce_206 = happySpecReduce_3  47# happyReduction_206+happyReduction_206 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut51 happy_x_1 of { happy_var_1 -> +	case happyOut52 happy_x_3 of { happy_var_3 -> +	happyIn53+		 ([happy_var_3, happy_var_1]+	)}}++happyReduce_207 = happySpecReduce_1  47# happyReduction_207+happyReduction_207 happy_x_1+	 =  case happyOut50 happy_x_1 of { happy_var_1 -> +	happyIn53+		 ([happy_var_1]+	)}++happyReduce_208 = happySpecReduce_2  48# happyReduction_208+happyReduction_208 happy_x_2+	happy_x_1+	 =  case happyOut55 happy_x_1 of { happy_var_1 -> +	happyIn54+		 (happy_var_1+	)}++happyReduce_209 = happySpecReduce_2  49# happyReduction_209+happyReduction_209 happy_x_2+	happy_x_1+	 =  case happyOut57 happy_x_1 of { happy_var_1 -> +	case happyOut55 happy_x_2 of { happy_var_2 -> +	happyIn55+		 (happy_var_1 ++ happy_var_2+	)}}++happyReduce_210 = happySpecReduce_2  49# happyReduction_210+happyReduction_210 happy_x_2+	happy_x_1+	 =  case happyOut44 happy_x_1 of { happy_var_1 -> +	case happyOut55 happy_x_2 of { happy_var_2 -> +	happyIn55+		 (DomainFull happy_var_1 : happy_var_2+	)}}++happyReduce_211 = happySpecReduce_1  49# happyReduction_211+happyReduction_211 happy_x_1+	 =  case happyOut57 happy_x_1 of { happy_var_1 -> +	happyIn55+		 (happy_var_1+	)}++happyReduce_212 = happySpecReduce_1  49# happyReduction_212+happyReduction_212 happy_x_1+	 =  case happyOut44 happy_x_1 of { happy_var_1 -> +	happyIn55+		 ([DomainFull happy_var_1]+	)}++happyReduce_213 = happySpecReduce_2  50# happyReduction_213+happyReduction_213 happy_x_2+	happy_x_1+	 =  case happyOut57 happy_x_1 of { happy_var_1 -> +	case happyOut56 happy_x_2 of { happy_var_2 -> +	happyIn56+		 (happy_var_1 ++ happy_var_2+	)}}++happyReduce_214 = happySpecReduce_2  50# happyReduction_214+happyReduction_214 happy_x_2+	happy_x_1+	 =  case happyOut44 happy_x_1 of { happy_var_1 -> +	case happyOut56 happy_x_2 of { happy_var_2 -> +	happyIn56+		 (DomainFull happy_var_1 : happy_var_2+	)}}++happyReduce_215 = happySpecReduce_0  50# happyReduction_215+happyReduction_215  =  happyIn56+		 ([]+	)++happyReduce_216 = happySpecReduce_1  51# happyReduction_216+happyReduction_216 happy_x_1+	 =  case happyOut58 happy_x_1 of { happy_var_1 -> +	happyIn57+		 (case happy_var_1 of+                             Left lbs -> lbs+                             Right _ -> fail "expected sequence of bound identifiers, not absurd pattern"+	)}++happyReduce_217 = happySpecReduce_1  52# happyReduction_217+happyReduction_217 happy_x_1+	 =  case happyOut23 happy_x_1 of { happy_var_1 -> +	happyIn58+		 (Left [DomainFree NotHidden Relevant $ mkBoundName_ happy_var_1]+	)}++happyReduce_218 = happySpecReduce_2  52# happyReduction_218+happyReduction_218 happy_x_2+	happy_x_1+	 =  case happyOut23 happy_x_2 of { happy_var_2 -> +	happyIn58+		 (Left [DomainFree NotHidden Irrelevant $ mkBoundName_ happy_var_2]+	)}++happyReduce_219 = happySpecReduce_2  52# happyReduction_219+happyReduction_219 happy_x_2+	happy_x_1+	 =  case happyOut23 happy_x_2 of { happy_var_2 -> +	happyIn58+		 (Left [DomainFree NotHidden NonStrict $ mkBoundName_ happy_var_2]+	)}++happyReduce_220 = happySpecReduce_3  52# happyReduction_220+happyReduction_220 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut26 happy_x_2 of { happy_var_2 -> +	happyIn58+		 (either (Left . map (DomainFree Hidden Relevant . mkBoundName_)) Right happy_var_2+	)}++happyReduce_221 = happySpecReduce_3  52# happyReduction_221+happyReduction_221 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut25 happy_x_2 of { happy_var_2 -> +	happyIn58+		 (Left $ map (DomainFree Instance Relevant . mkBoundName_) happy_var_2+	)}++happyReduce_222 = happyReduce 4# 52# happyReduction_222+happyReduction_222 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut25 happy_x_3 of { happy_var_3 -> +	happyIn58+		 (Left $ map (DomainFree Hidden Irrelevant . mkBoundName_) happy_var_3+	) `HappyStk` happyRest}++happyReduce_223 = happyReduce 4# 52# happyReduction_223+happyReduction_223 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut25 happy_x_3 of { happy_var_3 -> +	happyIn58+		 (Left $ map (DomainFree Instance Irrelevant . mkBoundName_) happy_var_3+	) `HappyStk` happyRest}++happyReduce_224 = happyReduce 4# 52# happyReduction_224+happyReduction_224 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut25 happy_x_3 of { happy_var_3 -> +	happyIn58+		 (Left $ map (DomainFree Hidden NonStrict . mkBoundName_) happy_var_3+	) `HappyStk` happyRest}++happyReduce_225 = happyReduce 4# 52# happyReduction_225+happyReduction_225 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut25 happy_x_3 of { happy_var_3 -> +	happyIn58+		 (Left $ map (DomainFree Instance NonStrict . mkBoundName_) happy_var_3+	) `HappyStk` happyRest}++happyReduce_226 = happySpecReduce_1  53# happyReduction_226+happyReduction_226 happy_x_1+	 =  case happyOut60 happy_x_1 of { happy_var_1 -> +	happyIn59+		 ((Nothing, happy_var_1)+	)}++happyReduce_227 = happyMonadReduce 3# 53# happyReduction_227+happyReduction_227 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOutTok happy_x_1 of { (TokId happy_var_1) -> +	case happyOut15 happy_x_2 of { happy_var_2 -> +	case happyOut60 happy_x_3 of { happy_var_3 -> +	( isName "as" happy_var_1 >>+                               return (Just (AsName happy_var_2 (getRange (fst happy_var_1))), happy_var_3))}}}+	) (\r -> happyReturn (happyIn59 r))++happyReduce_228 = happyMonadReduce 1# 54# happyReduction_228+happyReduction_228 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut61 happy_x_1 of { happy_var_1 -> +	( verifyImportDirective happy_var_1)}+	) (\r -> happyReturn (happyIn60 r))++happyReduce_229 = happySpecReduce_2  55# happyReduction_229+happyReduction_229 happy_x_2+	happy_x_1+	 =  case happyOut62 happy_x_2 of { happy_var_2 -> +	happyIn61+		 (happy_var_2 { publicOpen = True }+	)}++happyReduce_230 = happySpecReduce_1  55# happyReduction_230+happyReduction_230 happy_x_1+	 =  case happyOut62 happy_x_1 of { happy_var_1 -> +	happyIn61+		 (happy_var_1+	)}++happyReduce_231 = happySpecReduce_2  56# happyReduction_231+happyReduction_231 happy_x_2+	happy_x_1+	 =  case happyOut63 happy_x_1 of { happy_var_1 -> +	case happyOut64 happy_x_2 of { happy_var_2 -> +	happyIn62+		 (ImportDirective (fuseRange (snd happy_var_1) (snd happy_var_2)) (fst happy_var_1) (fst happy_var_2) False+	)}}++happyReduce_232 = happySpecReduce_1  56# happyReduction_232+happyReduction_232 happy_x_1+	 =  case happyOut64 happy_x_1 of { happy_var_1 -> +	happyIn62+		 (ImportDirective (getRange (snd happy_var_1)) (Hiding []) (fst happy_var_1) False+	)}++happyReduce_233 = happySpecReduce_1  56# happyReduction_233+happyReduction_233 happy_x_1+	 =  case happyOut63 happy_x_1 of { happy_var_1 -> +	happyIn62+		 (ImportDirective (getRange (snd happy_var_1)) (fst happy_var_1) [] False+	)}++happyReduce_234 = happySpecReduce_0  56# happyReduction_234+happyReduction_234  =  happyIn62+		 (ImportDirective noRange (Hiding []) [] False+	)++happyReduce_235 = happyReduce 4# 57# happyReduction_235+happyReduction_235 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { (TokKeyword KwUsing happy_var_1) -> +	case happyOut69 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (TokSymbol SymCloseParen happy_var_4) -> +	happyIn63+		 ((Using happy_var_3 , fuseRange happy_var_1 happy_var_4)+	) `HappyStk` happyRest}}}++happyReduce_236 = happyReduce 4# 57# happyReduction_236+happyReduction_236 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { (TokKeyword KwHiding happy_var_1) -> +	case happyOut70 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (TokSymbol SymCloseParen happy_var_4) -> +	happyIn63+		 ((Hiding happy_var_3 , fuseRange happy_var_1 happy_var_4)+	) `HappyStk` happyRest}}}++happyReduce_237 = happyReduce 4# 58# happyReduction_237+happyReduction_237 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { (TokKeyword KwRenaming happy_var_1) -> +	case happyOut65 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (TokSymbol SymCloseParen happy_var_4) -> +	happyIn64+		 ((happy_var_3 , fuseRange happy_var_1 happy_var_4)+	) `HappyStk` happyRest}}}++happyReduce_238 = happySpecReduce_3  59# happyReduction_238+happyReduction_238 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut66 happy_x_1 of { happy_var_1 -> +	case happyOut65 happy_x_3 of { happy_var_3 -> +	happyIn65+		 (happy_var_1 : happy_var_3+	)}}++happyReduce_239 = happySpecReduce_1  59# happyReduction_239+happyReduction_239 happy_x_1+	 =  case happyOut66 happy_x_1 of { happy_var_1 -> +	happyIn65+		 ([happy_var_1]+	)}++happyReduce_240 = happySpecReduce_3  60# happyReduction_240+happyReduction_240 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut67 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (TokKeyword KwTo happy_var_2) -> +	case happyOut15 happy_x_3 of { happy_var_3 -> +	happyIn66+		 (Renaming happy_var_1 happy_var_3 (getRange happy_var_2)+	)}}}++happyReduce_241 = happySpecReduce_2  61# happyReduction_241+happyReduction_241 happy_x_2+	happy_x_1+	 =  case happyOut15 happy_x_2 of { happy_var_2 -> +	happyIn67+		 (ImportedName happy_var_2+	)}++happyReduce_242 = happySpecReduce_3  61# happyReduction_242+happyReduction_242 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut15 happy_x_3 of { happy_var_3 -> +	happyIn67+		 (ImportedModule happy_var_3+	)}++happyReduce_243 = happySpecReduce_1  62# happyReduction_243+happyReduction_243 happy_x_1+	 =  case happyOut15 happy_x_1 of { happy_var_1 -> +	happyIn68+		 (ImportedName happy_var_1+	)}++happyReduce_244 = happySpecReduce_2  62# happyReduction_244+happyReduction_244 happy_x_2+	happy_x_1+	 =  case happyOut15 happy_x_2 of { happy_var_2 -> +	happyIn68+		 (ImportedModule happy_var_2+	)}++happyReduce_245 = happySpecReduce_0  63# happyReduction_245+happyReduction_245  =  happyIn69+		 ([]+	)++happyReduce_246 = happySpecReduce_1  63# happyReduction_246+happyReduction_246 happy_x_1+	 =  case happyOut70 happy_x_1 of { happy_var_1 -> +	happyIn69+		 (happy_var_1+	)}++happyReduce_247 = happySpecReduce_1  64# happyReduction_247+happyReduction_247 happy_x_1+	 =  case happyOut68 happy_x_1 of { happy_var_1 -> +	happyIn70+		 ([happy_var_1]+	)}++happyReduce_248 = happySpecReduce_3  64# happyReduction_248+happyReduction_248 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut68 happy_x_1 of { happy_var_1 -> +	case happyOut70 happy_x_3 of { happy_var_3 -> +	happyIn70+		 (happy_var_1 : happy_var_3+	)}}++happyReduce_249 = happyMonadReduce 3# 65# happyReduction_249+happyReduction_249 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut30 happy_x_1 of { happy_var_1 -> +	case happyOut74 happy_x_2 of { happy_var_2 -> +	case happyOut73 happy_x_3 of { happy_var_3 -> +	( exprToLHS happy_var_1 >>= \p -> return (p happy_var_2 happy_var_3))}}}+	) (\r -> happyReturn (happyIn71 r))++happyReduce_250 = happyReduce 4# 65# happyReduction_250+happyReduction_250 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { (TokSymbol SymEllipsis happy_var_1) -> +	case happyOut72 happy_x_2 of { happy_var_2 -> +	case happyOut74 happy_x_3 of { happy_var_3 -> +	case happyOut73 happy_x_4 of { happy_var_4 -> +	happyIn71+		 (Ellipsis (fuseRange happy_var_1 happy_var_3) happy_var_2 happy_var_3 happy_var_4+	) `HappyStk` happyRest}}}}++happyReduce_251 = happySpecReduce_0  66# happyReduction_251+happyReduction_251  =  happyIn72+		 ([]+	)++happyReduce_252 = happyMonadReduce 3# 66# happyReduction_252+happyReduction_252 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut34 happy_x_2 of { happy_var_2 -> +	case happyOut72 happy_x_3 of { happy_var_3 -> +	( exprToPattern (RawApp (getRange happy_var_2) happy_var_2) >>= \p ->+		   return (p : happy_var_3))}}+	) (\r -> happyReturn (happyIn72 r))++happyReduce_253 = happySpecReduce_0  67# happyReduction_253+happyReduction_253  =  happyIn73+		 ([]+	)++happyReduce_254 = happySpecReduce_2  67# happyReduction_254+happyReduction_254 happy_x_2+	happy_x_1+	 =  case happyOut29 happy_x_2 of { happy_var_2 -> +	happyIn73+		 (case happy_var_2 of { WithApp _ e es -> e : es; e -> [e] }+	)}++happyReduce_255 = happySpecReduce_0  68# happyReduction_255+happyReduction_255  =  happyIn74+		 ([]+	)++happyReduce_256 = happySpecReduce_2  68# happyReduction_256+happyReduction_256 happy_x_2+	happy_x_1+	 =  case happyOut29 happy_x_2 of { happy_var_2 -> +	happyIn74+		 (case happy_var_2 of { WithApp _ e es -> e : es; e -> [e] }+	)}++happyReduce_257 = happySpecReduce_0  69# happyReduction_257+happyReduction_257  =  happyIn75+		 (NoWhere+	)++happyReduce_258 = happySpecReduce_2  69# happyReduction_258+happyReduction_258 happy_x_2+	happy_x_1+	 =  case happyOut130 happy_x_2 of { happy_var_2 -> +	happyIn75+		 (AnyWhere happy_var_2+	)}++happyReduce_259 = happyReduce 4# 69# happyReduction_259+happyReduction_259 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut15 happy_x_2 of { happy_var_2 -> +	case happyOut130 happy_x_4 of { happy_var_4 -> +	happyIn75+		 (SomeWhere happy_var_2 happy_var_4+	) `HappyStk` happyRest}}++happyReduce_260 = happySpecReduce_1  70# happyReduction_260+happyReduction_260 happy_x_1+	 =  case happyOut78 happy_x_1 of { happy_var_1 -> +	happyIn76+		 ([happy_var_1]+	)}++happyReduce_261 = happySpecReduce_1  70# happyReduction_261+happyReduction_261 happy_x_1+	 =  case happyOut89 happy_x_1 of { happy_var_1 -> +	happyIn76+		 (happy_var_1+	)}++happyReduce_262 = happySpecReduce_1  70# happyReduction_262+happyReduction_262 happy_x_1+	 =  case happyOut81 happy_x_1 of { happy_var_1 -> +	happyIn76+		 ([happy_var_1]+	)}++happyReduce_263 = happySpecReduce_1  70# happyReduction_263+happyReduction_263 happy_x_1+	 =  case happyOut83 happy_x_1 of { happy_var_1 -> +	happyIn76+		 ([happy_var_1]+	)}++happyReduce_264 = happySpecReduce_1  70# happyReduction_264+happyReduction_264 happy_x_1+	 =  case happyOut84 happy_x_1 of { happy_var_1 -> +	happyIn76+		 ([happy_var_1]+	)}++happyReduce_265 = happySpecReduce_1  70# happyReduction_265+happyReduction_265 happy_x_1+	 =  case happyOut85 happy_x_1 of { happy_var_1 -> +	happyIn76+		 ([happy_var_1]+	)}++happyReduce_266 = happySpecReduce_1  70# happyReduction_266+happyReduction_266 happy_x_1+	 =  case happyOut86 happy_x_1 of { happy_var_1 -> +	happyIn76+		 ([happy_var_1]+	)}++happyReduce_267 = happySpecReduce_1  70# happyReduction_267+happyReduction_267 happy_x_1+	 =  case happyOut88 happy_x_1 of { happy_var_1 -> +	happyIn76+		 ([happy_var_1]+	)}++happyReduce_268 = happySpecReduce_1  70# happyReduction_268+happyReduction_268 happy_x_1+	 =  case happyOut90 happy_x_1 of { happy_var_1 -> +	happyIn76+		 ([happy_var_1]+	)}++happyReduce_269 = happySpecReduce_1  70# happyReduction_269+happyReduction_269 happy_x_1+	 =  case happyOut91 happy_x_1 of { happy_var_1 -> +	happyIn76+		 ([happy_var_1]+	)}++happyReduce_270 = happySpecReduce_1  70# happyReduction_270+happyReduction_270 happy_x_1+	 =  case happyOut92 happy_x_1 of { happy_var_1 -> +	happyIn76+		 ([happy_var_1]+	)}++happyReduce_271 = happySpecReduce_1  70# happyReduction_271+happyReduction_271 happy_x_1+	 =  case happyOut93 happy_x_1 of { happy_var_1 -> +	happyIn76+		 ([happy_var_1]+	)}++happyReduce_272 = happySpecReduce_1  70# happyReduction_272+happyReduction_272 happy_x_1+	 =  case happyOut94 happy_x_1 of { happy_var_1 -> +	happyIn76+		 ([happy_var_1]+	)}++happyReduce_273 = happySpecReduce_1  70# happyReduction_273+happyReduction_273 happy_x_1+	 =  case happyOut100 happy_x_1 of { happy_var_1 -> +	happyIn76+		 ([happy_var_1]+	)}++happyReduce_274 = happySpecReduce_1  70# happyReduction_274+happyReduction_274 happy_x_1+	 =  case happyOut104 happy_x_1 of { happy_var_1 -> +	happyIn76+		 ([happy_var_1]+	)}++happyReduce_275 = happySpecReduce_1  70# happyReduction_275+happyReduction_275 happy_x_1+	 =  case happyOut103 happy_x_1 of { happy_var_1 -> +	happyIn76+		 ([happy_var_1]+	)}++happyReduce_276 = happySpecReduce_1  70# happyReduction_276+happyReduction_276 happy_x_1+	 =  case happyOut105 happy_x_1 of { happy_var_1 -> +	happyIn76+		 ([happy_var_1]+	)}++happyReduce_277 = happySpecReduce_1  70# happyReduction_277+happyReduction_277 happy_x_1+	 =  case happyOut108 happy_x_1 of { happy_var_1 -> +	happyIn76+		 ([happy_var_1]+	)}++happyReduce_278 = happySpecReduce_1  70# happyReduction_278+happyReduction_278 happy_x_1+	 =  case happyOut95 happy_x_1 of { happy_var_1 -> +	happyIn76+		 ([happy_var_1]+	)}++happyReduce_279 = happySpecReduce_3  71# happyReduction_279+happyReduction_279 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut16 happy_x_1 of { happy_var_1 -> +	case happyOut29 happy_x_3 of { happy_var_3 -> +	happyIn77+		 (map (flip (TypeSig Relevant) happy_var_3) happy_var_1+	)}}++happyReduce_280 = happyReduce 4# 72# happyReduction_280+happyReduction_280 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut15 happy_x_2 of { happy_var_2 -> +	case happyOut29 happy_x_4 of { happy_var_4 -> +	happyIn78+		 (TypeSig Irrelevant happy_var_2 happy_var_4+	) `HappyStk` happyRest}}++happyReduce_281 = happySpecReduce_3  72# happyReduction_281+happyReduction_281 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut15 happy_x_1 of { happy_var_1 -> +	case happyOut29 happy_x_3 of { happy_var_3 -> +	happyIn78+		 (TypeSig Relevant happy_var_1 happy_var_3+	)}}++happyReduce_282 = happySpecReduce_3  73# happyReduction_282+happyReduction_282 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut19 happy_x_1 of { happy_var_1 -> +	case happyOut29 happy_x_3 of { happy_var_3 -> +	happyIn79+		 (map (\ (Arg _ rel x) -> TypeSig rel x happy_var_3) happy_var_1+	)}}++happyReduce_283 = happySpecReduce_3  74# happyReduction_283+happyReduction_283 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut20 happy_x_1 of { happy_var_1 -> +	case happyOut29 happy_x_3 of { happy_var_3 -> +	happyIn80+		 (map (fmap (flip (TypeSig Relevant) happy_var_3)) happy_var_1+	)}}++happyReduce_284 = happySpecReduce_3  75# happyReduction_284+happyReduction_284 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut71 happy_x_1 of { happy_var_1 -> +	case happyOut82 happy_x_2 of { happy_var_2 -> +	case happyOut75 happy_x_3 of { happy_var_3 -> +	happyIn81+		 (FunClause happy_var_1 happy_var_2 happy_var_3+	)}}}++happyReduce_285 = happySpecReduce_2  76# happyReduction_285+happyReduction_285 happy_x_2+	happy_x_1+	 =  case happyOut29 happy_x_2 of { happy_var_2 -> +	happyIn82+		 (RHS happy_var_2+	)}++happyReduce_286 = happySpecReduce_0  76# happyReduction_286+happyReduction_286  =  happyIn82+		 (AbsurdRHS+	)++happyReduce_287 = happyReduce 7# 77# happyReduction_287+happyReduction_287 (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 happyOutTok happy_x_1 of { (TokKeyword KwData happy_var_1) -> +	case happyOut15 happy_x_2 of { happy_var_2 -> +	case happyOut56 happy_x_3 of { happy_var_3 -> +	case happyOut29 happy_x_5 of { happy_var_5 -> +	case happyOutTok happy_x_6 of { (TokKeyword KwWhere happy_var_6) -> +	case happyOut128 happy_x_7 of { happy_var_7 -> +	happyIn83+		 (Data (getRange (happy_var_1, happy_var_6, happy_var_7)) Inductive happy_var_2 happy_var_3 (Just happy_var_5) happy_var_7+	) `HappyStk` happyRest}}}}}}++happyReduce_288 = happyReduce 7# 77# happyReduction_288+happyReduction_288 (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 happyOutTok happy_x_1 of { (TokKeyword KwCoData happy_var_1) -> +	case happyOut15 happy_x_2 of { happy_var_2 -> +	case happyOut56 happy_x_3 of { happy_var_3 -> +	case happyOut29 happy_x_5 of { happy_var_5 -> +	case happyOutTok happy_x_6 of { (TokKeyword KwWhere happy_var_6) -> +	case happyOut128 happy_x_7 of { happy_var_7 -> +	happyIn83+		 (Data (getRange (happy_var_1, happy_var_6, happy_var_7)) CoInductive happy_var_2 happy_var_3 (Just happy_var_5) happy_var_7+	) `HappyStk` happyRest}}}}}}++happyReduce_289 = happyReduce 5# 77# happyReduction_289+happyReduction_289 (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 { (TokKeyword KwData happy_var_1) -> +	case happyOut15 happy_x_2 of { happy_var_2 -> +	case happyOut56 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (TokKeyword KwWhere happy_var_4) -> +	case happyOut128 happy_x_5 of { happy_var_5 -> +	happyIn83+		 (Data (getRange (happy_var_1, happy_var_4, happy_var_5)) Inductive happy_var_2 happy_var_3 Nothing happy_var_5+	) `HappyStk` happyRest}}}}}++happyReduce_290 = happyReduce 5# 77# happyReduction_290+happyReduction_290 (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 { (TokKeyword KwCoData happy_var_1) -> +	case happyOut15 happy_x_2 of { happy_var_2 -> +	case happyOut56 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (TokKeyword KwWhere happy_var_4) -> +	case happyOut128 happy_x_5 of { happy_var_5 -> +	happyIn83+		 (Data (getRange (happy_var_1, happy_var_4, happy_var_5)) CoInductive happy_var_2 happy_var_3 Nothing happy_var_5+	) `HappyStk` happyRest}}}}}++happyReduce_291 = happyReduce 5# 78# happyReduction_291+happyReduction_291 (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 { (TokKeyword KwData happy_var_1) -> +	case happyOut15 happy_x_2 of { happy_var_2 -> +	case happyOut56 happy_x_3 of { happy_var_3 -> +	case happyOut29 happy_x_5 of { happy_var_5 -> +	happyIn84+		 (DataSig (fuseRange happy_var_1 happy_var_5) Inductive happy_var_2 happy_var_3 happy_var_5+	) `HappyStk` happyRest}}}}++happyReduce_292 = happyReduce 7# 79# happyReduction_292+happyReduction_292 (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 happyOutTok happy_x_1 of { (TokKeyword KwRecord happy_var_1) -> +	case happyOut15 happy_x_2 of { happy_var_2 -> +	case happyOut56 happy_x_3 of { happy_var_3 -> +	case happyOut29 happy_x_5 of { happy_var_5 -> +	case happyOutTok happy_x_6 of { (TokKeyword KwWhere happy_var_6) -> +	case happyOut129 happy_x_7 of { happy_var_7 -> +	happyIn85+		 (Record (getRange (happy_var_1, happy_var_6, happy_var_7)) happy_var_2 (fst happy_var_7) happy_var_3 (Just happy_var_5) (snd happy_var_7)+	) `HappyStk` happyRest}}}}}}++happyReduce_293 = happyReduce 5# 79# happyReduction_293+happyReduction_293 (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 { (TokKeyword KwRecord happy_var_1) -> +	case happyOut15 happy_x_2 of { happy_var_2 -> +	case happyOut56 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (TokKeyword KwWhere happy_var_4) -> +	case happyOut129 happy_x_5 of { happy_var_5 -> +	happyIn85+		 (Record (getRange (happy_var_1, happy_var_4, happy_var_5)) happy_var_2 (fst happy_var_5) happy_var_3 Nothing (snd happy_var_5)+	) `HappyStk` happyRest}}}}}++happyReduce_294 = happyReduce 5# 80# happyReduction_294+happyReduction_294 (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 { (TokKeyword KwRecord happy_var_1) -> +	case happyOut15 happy_x_2 of { happy_var_2 -> +	case happyOut56 happy_x_3 of { happy_var_3 -> +	case happyOut29 happy_x_5 of { happy_var_5 -> +	happyIn86+		 (RecordSig (fuseRange happy_var_1 happy_var_5) happy_var_2 happy_var_3 happy_var_5+	) `HappyStk` happyRest}}}}++happyReduce_295 = happySpecReduce_2  81# happyReduction_295+happyReduction_295 happy_x_2+	happy_x_1+	 =  case happyOut15 happy_x_2 of { happy_var_2 -> +	happyIn87+		 (happy_var_2+	)}++happyReduce_296 = happySpecReduce_3  82# happyReduction_296+happyReduction_296 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwInfix happy_var_1) -> +	case happyOut14 happy_x_2 of { happy_var_2 -> +	case happyOut24 happy_x_3 of { happy_var_3 -> +	happyIn88+		 (Infix (NonAssoc (fuseRange happy_var_1 happy_var_3) happy_var_2) happy_var_3+	)}}}++happyReduce_297 = happySpecReduce_3  82# happyReduction_297+happyReduction_297 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwInfixL happy_var_1) -> +	case happyOut14 happy_x_2 of { happy_var_2 -> +	case happyOut24 happy_x_3 of { happy_var_3 -> +	happyIn88+		 (Infix (LeftAssoc (fuseRange happy_var_1 happy_var_3) happy_var_2) happy_var_3+	)}}}++happyReduce_298 = happySpecReduce_3  82# happyReduction_298+happyReduction_298 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwInfixR happy_var_1) -> +	case happyOut14 happy_x_2 of { happy_var_2 -> +	case happyOut24 happy_x_3 of { happy_var_3 -> +	happyIn88+		 (Infix (RightAssoc (fuseRange happy_var_1 happy_var_3) happy_var_2) happy_var_3+	)}}}++happyReduce_299 = happySpecReduce_2  83# happyReduction_299+happyReduction_299 happy_x_2+	happy_x_1+	 =  case happyOut126 happy_x_2 of { happy_var_2 -> +	happyIn89+		 (let toField (Arg h rel (TypeSig _ x t)) = Field x (Arg h rel t) in map toField happy_var_2+	)}++happyReduce_300 = happySpecReduce_2  84# happyReduction_300+happyReduction_300 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwMutual happy_var_1) -> +	case happyOut130 happy_x_2 of { happy_var_2 -> +	happyIn90+		 (Mutual (fuseRange happy_var_1 happy_var_2) happy_var_2+	)}}++happyReduce_301 = happySpecReduce_2  85# happyReduction_301+happyReduction_301 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwAbstract happy_var_1) -> +	case happyOut130 happy_x_2 of { happy_var_2 -> +	happyIn91+		 (Abstract (fuseRange happy_var_1 happy_var_2) happy_var_2+	)}}++happyReduce_302 = happySpecReduce_2  86# happyReduction_302+happyReduction_302 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwPrivate happy_var_1) -> +	case happyOut130 happy_x_2 of { happy_var_2 -> +	happyIn92+		 (Private (fuseRange happy_var_1 happy_var_2) happy_var_2+	)}}++happyReduce_303 = happySpecReduce_2  87# happyReduction_303+happyReduction_303 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwPostulate happy_var_1) -> +	case happyOut124 happy_x_2 of { happy_var_2 -> +	happyIn93+		 (Postulate (fuseRange happy_var_1 happy_var_2) happy_var_2+	)}}++happyReduce_304 = happySpecReduce_2  88# happyReduction_304+happyReduction_304 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwPrimitive happy_var_1) -> +	case happyOut122 happy_x_2 of { happy_var_2 -> +	happyIn94+		 (Primitive (fuseRange happy_var_1 happy_var_2) happy_var_2+	)}}++happyReduce_305 = happyMonadReduce 5# 89# happyReduction_305+happyReduction_305 (happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut15 happy_x_2 of { happy_var_2 -> +	case happyOut97 happy_x_3 of { happy_var_3 -> +	case happyOut96 happy_x_5 of { happy_var_5 -> +	(+  case happy_var_2 of+    Name _ [_] -> case mkNotation happy_var_3 happy_var_5 of+      Left err -> parseError $ "malformed syntax declaration: " ++ err+      Right n -> return $ Syntax happy_var_2 n+    _ -> parseError "syntax declarations are allowed only for simple names (without holes)")}}}+	) (\r -> happyReturn (happyIn95 r))++happyReduce_306 = happySpecReduce_1  90# happyReduction_306+happyReduction_306 happy_x_1+	 =  case happyOut99 happy_x_1 of { happy_var_1 -> +	happyIn96+		 ([happy_var_1]+	)}++happyReduce_307 = happySpecReduce_2  90# happyReduction_307+happyReduction_307 happy_x_2+	happy_x_1+	 =  case happyOut96 happy_x_1 of { happy_var_1 -> +	case happyOut99 happy_x_2 of { happy_var_2 -> +	happyIn96+		 (happy_var_1 ++ [happy_var_2]+	)}}++happyReduce_308 = happySpecReduce_1  91# happyReduction_308+happyReduction_308 happy_x_1+	 =  case happyOut98 happy_x_1 of { happy_var_1 -> +	happyIn97+		 ([happy_var_1]+	)}++happyReduce_309 = happySpecReduce_2  91# happyReduction_309+happyReduction_309 happy_x_2+	happy_x_1+	 =  case happyOut97 happy_x_1 of { happy_var_1 -> +	case happyOut98 happy_x_2 of { happy_var_2 -> +	happyIn97+		 (happy_var_1 ++ [happy_var_2]+	)}}++happyReduce_310 = happySpecReduce_1  92# happyReduction_310+happyReduction_310 happy_x_1+	 =  case happyOut99 happy_x_1 of { happy_var_1 -> +	happyIn98+		 (ExprHole happy_var_1+	)}++happyReduce_311 = happyReduce 6# 92# happyReduction_311+happyReduction_311 (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 happyOut99 happy_x_3 of { happy_var_3 -> +	case happyOut99 happy_x_5 of { happy_var_5 -> +	happyIn98+		 (LambdaHole happy_var_3 happy_var_5+	) `HappyStk` happyRest}}++happyReduce_312 = happySpecReduce_1  93# happyReduction_312+happyReduction_312 happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokId happy_var_1) -> +	happyIn99+		 (snd happy_var_1+	)}++happyReduce_313 = happyReduce 4# 94# happyReduction_313+happyReduction_313 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { (TokKeyword KwOpen happy_var_1) -> +	case happyOut22 happy_x_2 of { happy_var_2 -> +	case happyOut101 happy_x_3 of { happy_var_3 -> +	case happyOut60 happy_x_4 of { happy_var_4 -> +	happyIn100+		 (let+    { m   = happy_var_2+    ; es  = happy_var_3+    ; dir = happy_var_4+    ; r   = getRange (happy_var_1, m, es, dir)+    } in+    case es of+    { []  -> Open r m dir+	; _   -> Private r [ ModuleMacro r (noName $ beginningOf $ getRange happy_var_2)+			     (SectionApp (getRange (m , es)) [] (RawApp (fuseRange m es) (Ident m : es)))+			     DoOpen dir+                       ]+    }+	) `HappyStk` happyRest}}}}++happyReduce_314 = happyReduce 6# 94# happyReduction_314+happyReduction_314 (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 { (TokKeyword KwOpen happy_var_1) -> +	case happyOut22 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (TokSymbol SymDoubleOpenBrace happy_var_3) -> +	case happyOutTok happy_x_4 of { (TokSymbol SymEllipsis happy_var_4) -> +	case happyOut60 happy_x_6 of { happy_var_6 -> +	happyIn100+		 (let r = getRange (happy_var_1, happy_var_2, happy_var_3, happy_var_4) in+    Private r [ ModuleMacro r (noName $ beginningOf $ getRange happy_var_2)+    	      	(RecordModuleIFS r happy_var_2) DoOpen happy_var_6+        ]+	) `HappyStk` happyRest}}}}}++happyReduce_315 = happySpecReduce_0  95# happyReduction_315+happyReduction_315  =  happyIn101+		 ([]+	)++happyReduce_316 = happySpecReduce_2  95# happyReduction_316+happyReduction_316 happy_x_2+	happy_x_1+	 =  case happyOut37 happy_x_1 of { happy_var_1 -> +	case happyOut101 happy_x_2 of { happy_var_2 -> +	happyIn101+		 (happy_var_1 : happy_var_2+	)}}++happyReduce_317 = happyReduce 4# 96# happyReduction_317+happyReduction_317 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut22 happy_x_1 of { happy_var_1 -> +	case happyOut17 happy_x_4 of { happy_var_4 -> +	happyIn102+		 ((\ts ->+		    if null ts then return $ RecordModuleIFS (getRange (happy_var_1, happy_var_4)) happy_var_1+		    else parseError "No bindings allowed for record module with non-canonical implicits" )+	) `HappyStk` happyRest}}++happyReduce_318 = happySpecReduce_2  96# happyReduction_318+happyReduction_318 happy_x_2+	happy_x_1+	 =  case happyOut22 happy_x_1 of { happy_var_1 -> +	case happyOut101 happy_x_2 of { happy_var_2 -> +	happyIn102+		 ((\ts -> return $ SectionApp (getRange (happy_var_1, happy_var_2)) ts (RawApp (fuseRange happy_var_1 happy_var_2) (Ident happy_var_1 : happy_var_2)) )+	)}}++happyReduce_319 = happyMonadReduce 6# 97# happyReduction_319+happyReduction_319 (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) tk+	 = happyThen (case happyOutTok happy_x_1 of { (TokKeyword KwModule happy_var_1) -> +	case happyOut15 happy_x_2 of { happy_var_2 -> +	case happyOut56 happy_x_3 of { happy_var_3 -> +	case happyOut102 happy_x_5 of { happy_var_5 -> +	case happyOut60 happy_x_6 of { happy_var_6 -> +	( do {ma <- happy_var_5 (map addType happy_var_3); return $ ModuleMacro (getRange (happy_var_1, ma, happy_var_6)) happy_var_2 ma DontOpen happy_var_6 })}}}}}+	) (\r -> happyReturn (happyIn103 r))++happyReduce_320 = happyMonadReduce 7# 97# happyReduction_320+happyReduction_320 (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) tk+	 = happyThen (case happyOutTok happy_x_1 of { (TokKeyword KwOpen happy_var_1) -> +	case happyOut15 happy_x_3 of { happy_var_3 -> +	case happyOut56 happy_x_4 of { happy_var_4 -> +	case happyOut102 happy_x_6 of { happy_var_6 -> +	case happyOut60 happy_x_7 of { happy_var_7 -> +	( do {ma <- happy_var_6 (map addType happy_var_4); return $ ModuleMacro (getRange (happy_var_1, ma, happy_var_7)) happy_var_3 ma DoOpen happy_var_7 })}}}}}+	) (\r -> happyReturn (happyIn103 r))++happyReduce_321 = happySpecReduce_3  98# happyReduction_321+happyReduction_321 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokKeyword KwImport happy_var_1) -> +	case happyOut22 happy_x_2 of { happy_var_2 -> +	case happyOut59 happy_x_3 of { happy_var_3 -> +	happyIn104+		 (Import (getRange (happy_var_1,happy_var_2,snd happy_var_3)) happy_var_2 (fst happy_var_3) DontOpen (snd happy_var_3)+	)}}}++happyReduce_322 = happyReduce 4# 98# happyReduction_322+happyReduction_322 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { (TokKeyword KwOpen happy_var_1) -> +	case happyOut22 happy_x_3 of { happy_var_3 -> +	case happyOut59 happy_x_4 of { happy_var_4 -> +	happyIn104+		 (Import (getRange (happy_var_1,happy_var_3,snd happy_var_4)) happy_var_3 (fst happy_var_4) DoOpen (snd happy_var_4)+	) `HappyStk` happyRest}}}++happyReduce_323 = happyReduce 5# 99# happyReduction_323+happyReduction_323 (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 { (TokKeyword KwModule happy_var_1) -> +	case happyOut15 happy_x_2 of { happy_var_2 -> +	case happyOut56 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (TokKeyword KwWhere happy_var_4) -> +	case happyOut131 happy_x_5 of { happy_var_5 -> +	happyIn105+		 (Module (getRange (happy_var_1,happy_var_4,happy_var_5)) (QName happy_var_2) (map addType happy_var_3) happy_var_5+	) `HappyStk` happyRest}}}}}++happyReduce_324 = happySpecReduce_1  100# happyReduction_324+happyReduction_324 happy_x_1+	 =  case happyOut107 happy_x_1 of { happy_var_1 -> +	happyIn106+		 ([happy_var_1]+	)}++happyReduce_325 = happySpecReduce_2  100# happyReduction_325+happyReduction_325 happy_x_2+	happy_x_1+	 =  case happyOut104 happy_x_1 of { happy_var_1 -> +	case happyOut106 happy_x_2 of { happy_var_2 -> +	happyIn106+		 (happy_var_1 : happy_var_2+	)}}++happyReduce_326 = happySpecReduce_2  100# happyReduction_326+happyReduction_326 happy_x_2+	happy_x_1+	 =  case happyOut100 happy_x_1 of { happy_var_1 -> +	case happyOut106 happy_x_2 of { happy_var_2 -> +	happyIn106+		 (happy_var_1 : happy_var_2+	)}}++happyReduce_327 = happyReduce 5# 101# happyReduction_327+happyReduction_327 (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 { (TokKeyword KwModule happy_var_1) -> +	case happyOut22 happy_x_2 of { happy_var_2 -> +	case happyOut56 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (TokKeyword KwWhere happy_var_4) -> +	case happyOut131 happy_x_5 of { happy_var_5 -> +	happyIn107+		 (Module (getRange (happy_var_1,happy_var_4,happy_var_5)) happy_var_2 (map addType happy_var_3) happy_var_5+	) `HappyStk` happyRest}}}}}++happyReduce_328 = happySpecReduce_1  102# happyReduction_328+happyReduction_328 happy_x_1+	 =  case happyOut110 happy_x_1 of { happy_var_1 -> +	happyIn108+		 (Pragma happy_var_1+	)}++happyReduce_329 = happySpecReduce_1  103# happyReduction_329+happyReduction_329 happy_x_1+	 =  case happyOut111 happy_x_1 of { happy_var_1 -> +	happyIn109+		 (happy_var_1+	)}++happyReduce_330 = happySpecReduce_1  104# happyReduction_330+happyReduction_330 happy_x_1+	 =  case happyOut112 happy_x_1 of { happy_var_1 -> +	happyIn110+		 (happy_var_1+	)}++happyReduce_331 = happySpecReduce_1  104# happyReduction_331+happyReduction_331 happy_x_1+	 =  case happyOut113 happy_x_1 of { happy_var_1 -> +	happyIn110+		 (happy_var_1+	)}++happyReduce_332 = happySpecReduce_1  104# happyReduction_332+happyReduction_332 happy_x_1+	 =  case happyOut115 happy_x_1 of { happy_var_1 -> +	happyIn110+		 (happy_var_1+	)}++happyReduce_333 = happySpecReduce_1  104# happyReduction_333+happyReduction_333 happy_x_1+	 =  case happyOut114 happy_x_1 of { happy_var_1 -> +	happyIn110+		 (happy_var_1+	)}++happyReduce_334 = happySpecReduce_1  104# happyReduction_334+happyReduction_334 happy_x_1+	 =  case happyOut116 happy_x_1 of { happy_var_1 -> +	happyIn110+		 (happy_var_1+	)}++happyReduce_335 = happySpecReduce_1  104# happyReduction_335+happyReduction_335 happy_x_1+	 =  case happyOut117 happy_x_1 of { happy_var_1 -> +	happyIn110+		 (happy_var_1+	)}++happyReduce_336 = happySpecReduce_1  104# happyReduction_336+happyReduction_336 happy_x_1+	 =  case happyOut118 happy_x_1 of { happy_var_1 -> +	happyIn110+		 (happy_var_1+	)}++happyReduce_337 = happySpecReduce_1  104# happyReduction_337+happyReduction_337 happy_x_1+	 =  case happyOut120 happy_x_1 of { happy_var_1 -> +	happyIn110+		 (happy_var_1+	)}++happyReduce_338 = happySpecReduce_1  104# happyReduction_338+happyReduction_338 happy_x_1+	 =  case happyOut121 happy_x_1 of { happy_var_1 -> +	happyIn110+		 (happy_var_1+	)}++happyReduce_339 = happySpecReduce_1  104# happyReduction_339+happyReduction_339 happy_x_1+	 =  case happyOut119 happy_x_1 of { happy_var_1 -> +	happyIn110+		 (happy_var_1+	)}++happyReduce_340 = happyReduce 4# 105# happyReduction_340+happyReduction_340 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> +	case happyOut27 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (TokSymbol SymClosePragma happy_var_4) -> +	happyIn111+		 (OptionsPragma (fuseRange happy_var_1 happy_var_4) happy_var_3+	) `HappyStk` happyRest}}}++happyReduce_341 = happyReduce 5# 106# happyReduction_341+happyReduction_341 (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 { (TokSymbol SymOpenPragma happy_var_1) -> +	case happyOutTok happy_x_3 of { (TokString happy_var_3) -> +	case happyOut28 happy_x_4 of { happy_var_4 -> +	case happyOutTok happy_x_5 of { (TokSymbol SymClosePragma happy_var_5) -> +	happyIn112+		 (BuiltinPragma (fuseRange happy_var_1 happy_var_5) (snd happy_var_3) (Ident happy_var_4)+	) `HappyStk` happyRest}}}}++happyReduce_342 = happyReduce 5# 107# happyReduction_342+happyReduction_342 (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 { (TokSymbol SymOpenPragma happy_var_1) -> +	case happyOut28 happy_x_3 of { happy_var_3 -> +	case happyOut27 happy_x_4 of { happy_var_4 -> +	case happyOutTok happy_x_5 of { (TokSymbol SymClosePragma happy_var_5) -> +	happyIn113+		 (CompiledPragma (fuseRange happy_var_1 happy_var_5) happy_var_3 (unwords happy_var_4)+	) `HappyStk` happyRest}}}}++happyReduce_343 = happyReduce 5# 108# happyReduction_343+happyReduction_343 (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 { (TokSymbol SymOpenPragma happy_var_1) -> +	case happyOut28 happy_x_3 of { happy_var_3 -> +	case happyOut27 happy_x_4 of { happy_var_4 -> +	case happyOutTok happy_x_5 of { (TokSymbol SymClosePragma happy_var_5) -> +	happyIn114+		 (CompiledTypePragma (fuseRange happy_var_1 happy_var_5) happy_var_3 (unwords happy_var_4)+	) `HappyStk` happyRest}}}}++happyReduce_344 = happyReduce 6# 109# happyReduction_344+happyReduction_344 (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 { (TokSymbol SymOpenPragma happy_var_1) -> +	case happyOut28 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (TokString happy_var_4) -> +	case happyOut27 happy_x_5 of { happy_var_5 -> +	case happyOutTok happy_x_6 of { (TokSymbol SymClosePragma happy_var_6) -> +	happyIn115+		 (CompiledDataPragma (fuseRange happy_var_1 happy_var_6) happy_var_3 (snd happy_var_4) happy_var_5+	) `HappyStk` happyRest}}}}}++happyReduce_345 = happyReduce 5# 110# happyReduction_345+happyReduction_345 (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 { (TokSymbol SymOpenPragma happy_var_1) -> +	case happyOut28 happy_x_3 of { happy_var_3 -> +	case happyOut27 happy_x_4 of { happy_var_4 -> +	case happyOutTok happy_x_5 of { (TokSymbol SymClosePragma happy_var_5) -> +	happyIn116+		 (CompiledEpicPragma (fuseRange happy_var_1 happy_var_5) happy_var_3 (unwords happy_var_4)+	) `HappyStk` happyRest}}}}++happyReduce_346 = happyReduce 5# 111# happyReduction_346+happyReduction_346 (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 { (TokSymbol SymOpenPragma happy_var_1) -> +	case happyOut28 happy_x_3 of { happy_var_3 -> +	case happyOut27 happy_x_4 of { happy_var_4 -> +	case happyOutTok happy_x_5 of { (TokSymbol SymClosePragma happy_var_5) -> +	happyIn117+		 (CompiledJSPragma (fuseRange happy_var_1 happy_var_5) happy_var_3 (unwords happy_var_4)+	) `HappyStk` happyRest}}}}++happyReduce_347 = happyReduce 4# 112# happyReduction_347+happyReduction_347 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> +	case happyOut28 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (TokSymbol SymClosePragma happy_var_4) -> +	happyIn118+		 (StaticPragma (fuseRange happy_var_1 happy_var_4) happy_var_3+	) `HappyStk` happyRest}}}++happyReduce_348 = happyReduce 4# 113# happyReduction_348+happyReduction_348 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> +	case happyOut28 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (TokSymbol SymClosePragma happy_var_4) -> +	happyIn119+		 (EtaPragma (fuseRange happy_var_1 happy_var_4) happy_var_3+	) `HappyStk` happyRest}}}++happyReduce_349 = happyMonadReduce 4# 114# happyReduction_349+happyReduction_349 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> +	case happyOutTok happy_x_3 of { (TokString happy_var_3) -> +	case happyOutTok happy_x_4 of { (TokSymbol SymClosePragma happy_var_4) -> +	( let s = snd happy_var_3 in+       if validHaskellModuleName s+       then return $ ImportPragma (fuseRange happy_var_1 happy_var_4) s+       else parseError $ "Malformed module name: " ++ s ++ ".")}}}+	) (\r -> happyReturn (happyIn120 r))++happyReduce_350 = happySpecReduce_3  115# happyReduction_350+happyReduction_350 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> +	case happyOutTok happy_x_3 of { (TokSymbol SymClosePragma happy_var_3) -> +	happyIn121+		 (ImpossiblePragma (fuseRange happy_var_1 happy_var_3)+	)}}++happyReduce_351 = happySpecReduce_3  116# happyReduction_351+happyReduction_351 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut123 happy_x_2 of { happy_var_2 -> +	happyIn122+		 (reverse happy_var_2+	)}++happyReduce_352 = happySpecReduce_3  117# happyReduction_352+happyReduction_352 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut123 happy_x_1 of { happy_var_1 -> +	case happyOut77 happy_x_3 of { happy_var_3 -> +	happyIn123+		 (reverse happy_var_3 ++ happy_var_1+	)}}++happyReduce_353 = happySpecReduce_1  117# happyReduction_353+happyReduction_353 happy_x_1+	 =  case happyOut77 happy_x_1 of { happy_var_1 -> +	happyIn123+		 (reverse happy_var_1+	)}++happyReduce_354 = happySpecReduce_3  118# happyReduction_354+happyReduction_354 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut125 happy_x_2 of { happy_var_2 -> +	happyIn124+		 (reverse happy_var_2+	)}++happyReduce_355 = happySpecReduce_3  119# happyReduction_355+happyReduction_355 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut125 happy_x_1 of { happy_var_1 -> +	case happyOut79 happy_x_3 of { happy_var_3 -> +	happyIn125+		 (reverse happy_var_3 ++ happy_var_1+	)}}++happyReduce_356 = happySpecReduce_1  119# happyReduction_356+happyReduction_356 happy_x_1+	 =  case happyOut79 happy_x_1 of { happy_var_1 -> +	happyIn125+		 (reverse happy_var_1+	)}++happyReduce_357 = happySpecReduce_3  120# happyReduction_357+happyReduction_357 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut127 happy_x_2 of { happy_var_2 -> +	happyIn126+		 (reverse happy_var_2+	)}++happyReduce_358 = happySpecReduce_3  121# happyReduction_358+happyReduction_358 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut127 happy_x_1 of { happy_var_1 -> +	case happyOut80 happy_x_3 of { happy_var_3 -> +	happyIn127+		 (reverse happy_var_3 ++ happy_var_1+	)}}++happyReduce_359 = happySpecReduce_1  121# happyReduction_359+happyReduction_359 happy_x_1+	 =  case happyOut80 happy_x_1 of { happy_var_1 -> +	happyIn127+		 (reverse happy_var_1+	)}++happyReduce_360 = happySpecReduce_2  122# happyReduction_360+happyReduction_360 happy_x_2+	happy_x_1+	 =  happyIn128+		 ([]+	)++happyReduce_361 = happySpecReduce_1  122# happyReduction_361+happyReduction_361 happy_x_1+	 =  case happyOut122 happy_x_1 of { happy_var_1 -> +	happyIn128+		 (happy_var_1+	)}++happyReduce_362 = happySpecReduce_2  123# happyReduction_362+happyReduction_362 happy_x_2+	happy_x_1+	 =  happyIn129+		 ((Nothing, [])+	)++happyReduce_363 = happySpecReduce_3  123# happyReduction_363+happyReduction_363 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut87 happy_x_2 of { happy_var_2 -> +	happyIn129+		 ((Just happy_var_2, [])+	)}++happyReduce_364 = happyReduce 5# 123# happyReduction_364+happyReduction_364 (happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut87 happy_x_2 of { happy_var_2 -> +	case happyOut132 happy_x_4 of { happy_var_4 -> +	happyIn129+		 ((Just happy_var_2, reverse happy_var_4)+	) `HappyStk` happyRest}}++happyReduce_365 = happySpecReduce_3  123# happyReduction_365+happyReduction_365 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut132 happy_x_2 of { happy_var_2 -> +	happyIn129+		 ((Nothing, reverse happy_var_2)+	)}++happyReduce_366 = happySpecReduce_3  124# happyReduction_366+happyReduction_366 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut132 happy_x_2 of { happy_var_2 -> +	happyIn130+		 (reverse happy_var_2+	)}++happyReduce_367 = happySpecReduce_2  125# happyReduction_367+happyReduction_367 happy_x_2+	happy_x_1+	 =  happyIn131+		 ([]+	)++happyReduce_368 = happySpecReduce_1  125# happyReduction_368+happyReduction_368 happy_x_1+	 =  case happyOut130 happy_x_1 of { happy_var_1 -> +	happyIn131+		 (happy_var_1+	)}++happyReduce_369 = happySpecReduce_3  126# happyReduction_369+happyReduction_369 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut132 happy_x_1 of { happy_var_1 -> +	case happyOut76 happy_x_3 of { happy_var_3 -> +	happyIn132+		 (reverse happy_var_3 ++ happy_var_1+	)}}++happyReduce_370 = happySpecReduce_1  126# happyReduction_370+happyReduction_370 happy_x_1+	 =  case happyOut76 happy_x_1 of { happy_var_1 -> +	happyIn132+		 (reverse happy_var_1+	)}++happyNewToken action sts stk+	= lexer(\tk -> +	let cont i = happyDoAction i tk action sts stk in+	case tk of {+	TokEOF -> happyDoAction 76# tk action sts stk;+	TokKeyword KwLet happy_dollar_dollar -> cont 1#;+	TokKeyword KwIn happy_dollar_dollar -> cont 2#;+	TokKeyword KwWhere happy_dollar_dollar -> cont 3#;+	TokKeyword KwWith happy_dollar_dollar -> cont 4#;+	TokKeyword KwRewrite happy_dollar_dollar -> cont 5#;+	TokKeyword KwPostulate happy_dollar_dollar -> cont 6#;+	TokKeyword KwPrimitive happy_dollar_dollar -> cont 7#;+	TokKeyword KwOpen happy_dollar_dollar -> cont 8#;+	TokKeyword KwImport happy_dollar_dollar -> cont 9#;+	TokKeyword KwUsing happy_dollar_dollar -> cont 10#;+	TokKeyword KwHiding happy_dollar_dollar -> cont 11#;+	TokKeyword KwRenaming happy_dollar_dollar -> cont 12#;+	TokKeyword KwTo happy_dollar_dollar -> cont 13#;+	TokKeyword KwPublic happy_dollar_dollar -> cont 14#;+	TokKeyword KwModule happy_dollar_dollar -> cont 15#;+	TokKeyword KwData happy_dollar_dollar -> cont 16#;+	TokKeyword KwCoData happy_dollar_dollar -> cont 17#;+	TokKeyword KwRecord happy_dollar_dollar -> cont 18#;+	TokKeyword KwConstructor happy_dollar_dollar -> cont 19#;+	TokKeyword KwField happy_dollar_dollar -> cont 20#;+	TokKeyword KwInfix happy_dollar_dollar -> cont 21#;+	TokKeyword KwInfixL happy_dollar_dollar -> cont 22#;+	TokKeyword KwInfixR happy_dollar_dollar -> cont 23#;+	TokKeyword KwMutual happy_dollar_dollar -> cont 24#;+	TokKeyword KwAbstract happy_dollar_dollar -> cont 25#;+	TokKeyword KwPrivate happy_dollar_dollar -> cont 26#;+	TokKeyword KwProp happy_dollar_dollar -> cont 27#;+	TokKeyword KwSet happy_dollar_dollar -> cont 28#;+	TokKeyword KwForall happy_dollar_dollar -> cont 29#;+	TokKeyword KwSyntax happy_dollar_dollar -> cont 30#;+	TokKeyword KwOPTIONS happy_dollar_dollar -> cont 31#;+	TokKeyword KwBUILTIN happy_dollar_dollar -> cont 32#;+	TokKeyword KwIMPORT happy_dollar_dollar -> cont 33#;+	TokKeyword KwIMPOSSIBLE happy_dollar_dollar -> cont 34#;+	TokKeyword KwETA happy_dollar_dollar -> cont 35#;+	TokKeyword KwCOMPILED happy_dollar_dollar -> cont 36#;+	TokKeyword KwCOMPILED_DATA happy_dollar_dollar -> cont 37#;+	TokKeyword KwCOMPILED_TYPE happy_dollar_dollar -> cont 38#;+	TokKeyword KwCOMPILED_EPIC happy_dollar_dollar -> cont 39#;+	TokKeyword KwCOMPILED_JS happy_dollar_dollar -> cont 40#;+	TokKeyword KwSTATIC happy_dollar_dollar -> cont 41#;+	TokKeyword KwQuoteGoal happy_dollar_dollar -> cont 42#;+	TokKeyword KwQuote happy_dollar_dollar -> cont 43#;+	TokKeyword KwQuoteTerm happy_dollar_dollar -> cont 44#;+	TokKeyword KwUnquote happy_dollar_dollar -> cont 45#;+	TokSetN happy_dollar_dollar -> cont 46#;+	TokTeX happy_dollar_dollar -> cont 47#;+	TokComment happy_dollar_dollar -> cont 48#;+	TokSymbol SymEllipsis happy_dollar_dollar -> cont 49#;+	TokSymbol SymDotDot happy_dollar_dollar -> cont 50#;+	TokSymbol SymDot happy_dollar_dollar -> cont 51#;+	TokSymbol SymSemi happy_dollar_dollar -> cont 52#;+	TokSymbol SymColon happy_dollar_dollar -> cont 53#;+	TokSymbol SymEqual happy_dollar_dollar -> cont 54#;+	TokSymbol SymUnderscore happy_dollar_dollar -> cont 55#;+	TokSymbol SymQuestionMark happy_dollar_dollar -> cont 56#;+	TokSymbol SymArrow happy_dollar_dollar -> cont 57#;+	TokSymbol SymLambda happy_dollar_dollar -> cont 58#;+	TokSymbol SymAs happy_dollar_dollar -> cont 59#;+	TokSymbol SymBar happy_dollar_dollar -> cont 60#;+	TokSymbol SymOpenParen happy_dollar_dollar -> cont 61#;+	TokSymbol SymCloseParen happy_dollar_dollar -> cont 62#;+	TokSymbol SymDoubleOpenBrace happy_dollar_dollar -> cont 63#;+	TokSymbol SymDoubleCloseBrace happy_dollar_dollar -> cont 64#;+	TokSymbol SymOpenBrace happy_dollar_dollar -> cont 65#;+	TokSymbol SymCloseBrace happy_dollar_dollar -> cont 66#;+	TokSymbol SymOpenVirtualBrace happy_dollar_dollar -> cont 67#;+	TokSymbol SymCloseVirtualBrace happy_dollar_dollar -> cont 68#;+	TokSymbol SymVirtualSemi happy_dollar_dollar -> cont 69#;+	TokSymbol SymOpenPragma happy_dollar_dollar -> cont 70#;+	TokSymbol SymClosePragma happy_dollar_dollar -> cont 71#;+	TokId happy_dollar_dollar -> cont 72#;+	TokQId happy_dollar_dollar -> cont 73#;+	TokString happy_dollar_dollar -> cont 74#;+	TokLiteral happy_dollar_dollar -> cont 75#;+	_ -> happyError' tk+	})++happyError_ tk = happyError' tk++happyThen :: () => Parser a -> (a -> Parser b) -> Parser b+happyThen = (>>=)+happyReturn :: () => a -> Parser a+happyReturn = (return)+happyThen1 = happyThen+happyReturn1 :: () => a -> Parser a+happyReturn1 = happyReturn+happyError' :: () => (Token) -> Parser a+happyError' tk = (\token -> happyError) tk++tokensParser = happySomeParser where+  happySomeParser = happyThen (happyParse 0#) (\x -> happyReturn (happyOut6 x))++exprParser = happySomeParser where+  happySomeParser = happyThen (happyParse 1#) (\x -> happyReturn (happyOut29 x))++moduleParser = happySomeParser where+  happySomeParser = happyThen (happyParse 2#) (\x -> happyReturn (happyOut9 x))++happySeq = happyDontSeq+++{--------------------------------------------------------------------------+    Parsers+ --------------------------------------------------------------------------}++-- | Parse the token stream. Used by the TeX compiler.+tokensParser :: Parser [Token]++-- | Parse an expression. Could be used in interactions.+exprParser :: Parser Expr++-- | Parse a module.+moduleParser :: Parser Module+++{--------------------------------------------------------------------------+    Happy stuff+ --------------------------------------------------------------------------}++-- | Required by Happy.+happyError :: Parser a+happyError = parseError "Parse error"+++{--------------------------------------------------------------------------+    Utility functions+ --------------------------------------------------------------------------}++-- | Create a name from a string.++mkName :: (Interval, String) -> Parser Name+mkName (i, s) = do+    let xs = parts s+    mapM_ isValidId xs+    unless (alternating xs) $ fail $ "a name cannot contain two consecutive underscores"+    return $ Name (getRange i) xs+    where+        parts :: String -> [NamePart]+        parts ""        = []+        parts ('_' : s) = Hole : parts s+        parts s         = Id x : parts s'+          where (x, s') = break (== '_') s++	isValidId Hole   = return ()+	isValidId (Id x) = case parse defaultParseFlags [0] (lexer return) x of+	    ParseOk _ (TokId _) -> return ()+	    _			-> fail $ "in the name " ++ s ++ ", the part " ++ x ++ " is not valid"++	-- we know that there are no two Ids in a row+	alternating (Hole : Hole : _) = False+	alternating (_ : xs)	      = alternating xs+	alternating []		      = True++-- | Create a qualified name from a list of strings+mkQName :: [(Interval, String)] -> Parser QName+mkQName ss = do+    xs <- mapM mkName ss+    return $ foldr Qual (QName $ last xs) (init xs)++-- | Match a particular name.+isName :: String -> (Interval, String) -> Parser ()+isName s (_,s')+    | s == s'	= return ()+    | otherwise	= fail $ "expected " ++ s ++ ", found " ++ s'++-- | Build a forall pi (forall x y z -> ...)+forallPi :: [LamBinding] -> Expr -> Expr+forallPi bs e = Pi (map addType bs) e++-- | Converts lambda bindings to typed bindings.+addType :: LamBinding -> TypedBindings+addType (DomainFull b)	 = b+addType (DomainFree h rel x) = TypedBindings r $ Arg h rel $ TBind r [x] $ Underscore r Nothing+  where r = getRange x++-- | Check that an import directive doesn't contain repeated names+verifyImportDirective :: ImportDirective -> Parser ImportDirective+verifyImportDirective i =+    case filter ((>1) . length)+	 $ group+	 $ sort xs+    of+	[]  -> return i+	yss -> let Just pos = rStart $ getRange $ head $ concat yss in+               parseErrorAt pos $+		"repeated name" ++ s ++ " in import directive: " +++		concat (intersperse ", " $ map (show . head) yss)+	    where+		s = case yss of+			[_] -> ""+			_   -> "s"+    where+	xs = names (usingOrHiding i) ++ map renFrom (renaming i)+	names (Using xs)    = xs+	names (Hiding xs)   = xs++-- | Breaks up a string into substrings. Returns every maximal+-- subsequence of zero or more characters distinct from @'.'@.+--+-- > splitOnDots ""         == [""]+-- > splitOnDots "foo.bar"  == ["foo", "bar"]+-- > splitOnDots ".foo.bar" == ["", "foo", "bar"]+-- > splitOnDots "foo.bar." == ["foo", "bar", ""]+-- > splitOnDots "foo..bar" == ["foo", "", "bar"]+splitOnDots :: String -> [String]+splitOnDots ""        = [""]+splitOnDots ('.' : s) = [] : splitOnDots s+splitOnDots (c   : s) = case splitOnDots s of+  p : ps -> (c : p) : ps++prop_splitOnDots = and+  [ splitOnDots ""         == [""]+  , splitOnDots "foo.bar"  == ["foo", "bar"]+  , splitOnDots ".foo.bar" == ["", "foo", "bar"]+  , splitOnDots "foo.bar." == ["foo", "bar", ""]+  , splitOnDots "foo..bar" == ["foo", "", "bar"]+  ]++-- | Returns 'True' iff the name is a valid Haskell (hierarchical)+-- module name.+validHaskellModuleName :: String -> Bool+validHaskellModuleName = all ok . splitOnDots+  where+  -- Checks if a dot-less module name is well-formed.+  ok :: String -> Bool+  ok []      = False+  ok (c : s) =+    isUpper c &&+    all (\c -> isLower c || c == '_' ||+               isUpper c ||+               generalCategory c == DecimalNumber ||+               c == '\'')+        s++{--------------------------------------------------------------------------+    Patterns+ --------------------------------------------------------------------------}++-- | Turn an expression into a left hand side.+exprToLHS :: Expr -> Parser ([Expr] -> [Expr] -> LHS)+exprToLHS e = case e of+  WithApp r e es -> LHS <$> exprToPattern e <*> mapM exprToPattern es+  _		 -> LHS <$> exprToPattern e <*> return []++-- | Turn an expression into a pattern. Fails if the expression is not a+--   valid pattern.+exprToPattern :: Expr -> Parser Pattern+exprToPattern e =+    case e of+	Ident x			-> return $ IdentP x+	App _ e1 e2		-> AppP <$> exprToPattern e1+					<*> T.mapM (T.mapM exprToPattern) e2+	Paren r e		-> ParenP r+					<$> exprToPattern e+	Underscore r _		-> return $ WildP r+	Absurd r		-> return $ AbsurdP r+	As r x e		-> AsP r x <$> exprToPattern e+	Dot r (HiddenArg _ e)	-> return $ HiddenP r $ fmap (DotP r) e+	Dot r e			-> return $ DotP r e+	Lit l			-> return $ LitP l+	HiddenArg r e		-> HiddenP r <$> T.mapM exprToPattern e+	InstanceArg r e		-> InstanceP r <$> T.mapM exprToPattern e+	RawApp r es		-> RawAppP r <$> mapM exprToPattern es+	OpApp r x es		-> OpAppP r x <$> mapM opAppExprToPattern es+	_			->+          let Just pos = rStart $ getRange e in+          parseErrorAt pos $ "Not a valid pattern: " ++ show e++opAppExprToPattern :: OpApp Expr -> Parser Pattern+opAppExprToPattern (SyntaxBindingLambda _ _ _) = parseError "syntax binding lambda cannot appear in a pattern"+opAppExprToPattern (Ordinary e) = exprToPattern e++parsePanic s = parseError $ "Internal parser error: " ++ s ++ ". Please report this as a bug."++{--------------------------------------------------------------------------+    Tests+ --------------------------------------------------------------------------}++-- | Test suite.+tests :: IO Bool+tests = runTests "Agda.Syntax.Parser.Parser"+  [ quickCheck' prop_splitOnDots+  ]+{-# 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 =+--	trace "failing" $ +    	happyError_ 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"  -----------------------------------------------------------------------------

+ doc/release-notes/2-3-0.txt view

@@ -0,0 +1,1005 @@+------------------------------------------------------------------------+-- Release notes for Agda 2 version 2.3.0+------------------------------------------------------------------------++Important changes since 2.2.10:++Language+========++* New more liberal syntax for mutually recursive definitions.++  It is no longer necessary to use the 'mutual' keyword to define+  mutually recursive functions or datatypes. Instead, it is enough to+  declare things before they are used. Instead of++    mutual+      f : A+      f = a[f, g]++      g : B[f]+      g = b[f, g]++  you can now write++    f : A+    g : B[f]+    f = a[f, g]+    g = b[f, g].++  With the new style you have more freedom in choosing the order in+  which things are type checked (previously type signatures were+  always checked before definitions). Furthermore you can mix+  arbitrary declarations, such as modules and postulates, with+  mutually recursive definitions.++  For data types and records the following new syntax is used to+  separate the declaration from the definition:++    -- Declaration.+    data Vec (A : Set) : Nat → Set  -- Note the absence of 'where'.++    -- Definition.+    data Vec A where+      []   : Vec A zero+      _::_ : {n : Nat} → A → Vec A n → Vec A (suc n)++    -- Declaration.+    record Sigma (A : Set) (B : A → Set) : Set++    -- Definition.+    record Sigma A B where+      constructor _,_+      field fst : A+            snd : B fst++  When making separated declarations/definitions private or abstract+  you should attach the 'private' keyword to the declaration and the+  'abstract' keyword to the definition. For instance, a private,+  abstract function can be defined as++    private+      f : A+    abstract+      f = e++  Finally it may be worth noting that the old style of mutually+  recursive definitions is still supported (it basically desugars into+  the new style).++* Pattern matching lambdas.++  Anonymous pattern matching functions can be defined using the syntax++    \ { p11 .. p1n -> e1 ; ... ; pm1 .. pmn -> em }++  (where, as usual, \ and -> can be replaced by λ and →). Internally+  this is translated into a function definition of the following form:++    .extlam p11 .. p1n = e1+    ...+    .extlam pm1 .. pmn = em++  This means that anonymous pattern matching functions are generative.+  For instance, refl will not be accepted as an inhabitant of the type++    (λ { true → true ; false → false }) ≡+    (λ { true → true ; false → false }),++  because this is equivalent to extlam1 ≡ extlam2 for some distinct+  fresh names extlam1 and extlam2.++  Currently the 'where' and 'with' constructions are not allowed in+  (the top-level clauses of) anonymous pattern matching functions.++  Examples:++    and : Bool → Bool → Bool+    and = λ { true x → x ; false _ → false }++    xor : Bool → Bool → Bool+    xor = λ { true  true  → false+            ; false false → false+            ; _     _     → true+            }++    fst : {A : Set} {B : A → Set} → Σ A B → A+    fst = λ { (a , b) → a }++    snd : {A : Set} {B : A → Set} (p : Σ A B) → B (fst p)+    snd = λ { (a , b) → b }++* Record update syntax.++  Assume that we have a record type and a corresponding value:++    record MyRecord : Set where+      field+        a b c : ℕ++    old : MyRecord+    old = record { a = 1; b = 2; c = 3 }++  Then we can update (some of) the record value's fields in the+  following way:++    new : MyRecord+    new = record old { a = 0; c = 5 }++  Here new normalises to record { a = 0; b = 2; c = 5 }. Any+  expression yielding a value of type MyRecord can be used instead of+  old.++  Record updating is not allowed to change types: the resulting value+  must have the same type as the original one, including the record+  parameters. Thus, the type of a record update can be inferred if the type+  of the original record can be inferred.++  The record update syntax is expanded before type checking. When the+  expression++    record old { upd-fields }++  is checked against a record type R, it is expanded to++    let r = old in record { new-fields },++  where old is required to have type R and new-fields is defined as+  follows: for each field x in R,++    - if x = e is contained in upd-fields then x = e is included in+      new-fields, and otherwise+    - if x is an explicit field then x = R.x r is included in+      new-fields, and+    - if x is an implicit or instance field, then it is omitted from+      new-fields.++  (Instance arguments are explained below.) The reason for treating+  implicit and instance fields specially is to allow code like the+  following:++    record R : Set where+      field+        {length} : ℕ+        vec      : Vec ℕ length+        -- More fields…++    xs : R+    xs = record { vec = 0 ∷ 1 ∷ 2 ∷ [] }++    ys = record xs { vec = 0 ∷ [] }++  Without the special treatment the last expression would need to+  include a new binding for length (for instance "length = _").++* Record patterns which do not contain data type patterns, but which+  do contain dot patterns, are no longer rejected.++* When the --without-K flag is used literals are now treated as+  constructors.++* Under-applied functions can now reduce.++  Consider the following definition:++    id : {A : Set} → A → A+    id x = x++  Previously the expression id would not reduce. This has been changed+  so that it now reduces to λ x → x. Usually this makes little+  difference, but it can be important in conjunction with 'with'. See+  issue 365 for an example.++* Unused AgdaLight legacy syntax (x y : A; z v : B) for telescopes has+  been removed.++Universe polymorphism+---------------------++* Universe polymorphism is now enabled by default.+  Use --no-universe-polymorphism to disable it.++* Universe levels are no longer defined as a data type.++  The basic level combinators can be introduced in the following way:++  postulate+    Level : Set+    zero  : Level+    suc   : Level → Level+    max   : Level → Level → Level++  {-# BUILTIN LEVEL     Level #-}+  {-# BUILTIN LEVELZERO zero  #-}+  {-# BUILTIN LEVELSUC  suc   #-}+  {-# BUILTIN LEVELMAX  max   #-}++* The BUILTIN equality is now required to be universe-polymorphic.++* trustMe is now universe-polymorphic.++Meta-variables and unification+------------------------------++* Unsolved meta-variables are now frozen after every mutual block.+  This means that they cannot be instantiated by subsequent code. For+  instance,++    one : Nat+    one = _++    bla : one ≡ suc zero+    bla = refl++  leads to an error now, whereas previously it lead to the+  instantiation of _ with "suc zero". If you want to make use of the+  old behaviour, put the two definitions in a mutual block.++  All meta-variables are unfrozen during interactive editing, so that+  the user can fill holes interactively. Note that type-checking of+  interactively given terms is not perfect: Agda sometimes refuses to+  load a file, even though no complaints were raised during the+  interactive construction of the file. This is because certain checks+  (for instance, positivity) are only invoked when a file is loaded.++* Record types can now be inferred.++  If there is a unique known record type with fields matching the+  fields in a record expression, then the type of the expression will+  be inferred to be the record type applied to unknown parameters.++  If there is no known record type with the given fields the type+  checker will give an error instead of producing lots of unsolved+  meta-variables.++  Note that "known record type" refers to any record type in any+  imported module, not just types which are in scope.++* The occurrence checker distinguishes rigid and strongly rigid+  occurrences [Reed, LFMTP 2009; Abel & Pientka, TLCA 2011].++  The completeness checker now accepts the following code:++    h : (n : Nat) → n ≡ suc n → Nat+    h n ()++  Internally this generates a constraint _n = suc _n where the+  meta-variable _n occurs strongly rigidly, i.e. on a constructor path+  from the root, in its own defining term tree. This is never+  solvable.++  Weakly rigid recursive occurrences may have a solution [Jason Reed's+  PhD thesis, page 106]:++    test : (k : Nat) →+           let X : (Nat → Nat) → Nat+               X = _+           in+           (f : Nat → Nat) → X f ≡ suc (f (X (λ x → k)))+    test k f = refl++  The constraint _X k f = suc (f (_X k (λ x → k))) has the solution+  _X k f = suc (f (suc k)), despite the recursive occurrence of _X.+  Here _X is not strongly rigid, because it occurs under the bound+  variable f. Previously Agda rejected this code; now it instead+  complains about an unsolved meta-variable.++* Equation constraints involving the same meta-variable in the head+  now trigger pruning [Pientka, PhD, Sec. 3.1.2; Abel & Pientka, TLCA+  2011]. Example:++    same : let X : A → A → A → A × A+               X = _+           in {x y z : A} → X x y y ≡ (x , y)+                          × X x x y ≡ X x y y+    same = refl , refl++  The second equation implies that X cannot depend on its second+  argument. After pruning the first equation is linear and can be+  solved.++* Instance arguments.++  A new type of hidden function arguments has been added: instance+  arguments. This new feature is based on influences from Scala's+  implicits and Agda's existing implicit arguments.++  Plain implicit arguments are marked by single braces: {…}. Instance+  arguments are instead marked by double braces: {{…}}. Example:++    postulate+      A : Set+      B : A → Set+      a : A+      f : {{a : A}} → B a++  Instead of the double braces you can use the symbols ⦃ and ⦄, but+  these symbols must in many cases be surrounded by whitespace. (If+  you are using Emacs and the Agda input method, then you can conjure+  up the symbols by typing "\{{" and "\}}", respectively.)++  Instance arguments behave as ordinary implicit arguments, except for+  one important aspect: resolution of arguments which are not provided+  explicitly. For instance, consider the following code:++    test = f++  Here Agda will notice that f's instance argument was not provided+  explicitly, and try to infer it. All definitions in scope at f's+  call site, as well as all variables in the context, are considered.+  If exactly one of these names has the required type (A), then the+  instance argument will be instantiated to this name.++  This feature can be used as an alternative to Haskell type classes.+  If we define++    record Eq (A : Set) : Set where+      field equal : A → A → Bool,++  then we can define the following projection:++    equal : {A : Set} {{eq : Eq A}} → A → A → Bool+    equal {{eq}} = Eq.equal eq++  Now consider the following expression:++    equal false false ∨ equal 3 4++  If the following Eq "instances" for Bool and ℕ are in scope, and no+  others, then the expression is accepted:++    eq-Bool : Eq Bool+    eq-Bool = record { equal = … }++    eq-ℕ : Eq ℕ+    eq-ℕ = record { equal = … }++  A shorthand notation is provided to avoid the need to define+  projection functions manually:++    module Eq-with-implicits = Eq {{...}}++  This notation creates a variant of Eq's record module, where the+  main Eq argument is an instance argument instead of an explicit one.+  It is equivalent to the following definition:++    module Eq-with-implicits {A : Set} {{eq : Eq A}} = Eq eq++  Note that the short-hand notation allows you to avoid naming the+  "-with-implicits" module:++    open Eq {{...}}+++  Instance argument resolution is not recursive. As an example,+  consider the following "parametrised instance":++    eq-List : {A : Set} → Eq A → Eq (List A)+    eq-List {A} eq = record { equal = eq-List-A }+      where+      eq-List-A : List A → List A → Bool+      eq-List-A []       []       = true+      eq-List-A (a ∷ as) (b ∷ bs) = equal a b ∧ eq-List-A as bs+      eq-List-A _        _        = false++  Assume that the only Eq instances in scope are eq-List and eq-ℕ.+  Then the following code does not type-check:++    test = equal (1 ∷ 2 ∷ []) (3 ∷ 4 ∷ [])++  However, we can make the code work by constructing a suitable+  instance manually:++    test′ = equal (1 ∷ 2 ∷ []) (3 ∷ 4 ∷ [])+      where eq-List-ℕ = eq-List eq-ℕ++  By restricting the "instance search" to be non-recursive we avoid+  introducing a new, compile-time-only evaluation model to Agda.++  For more information about instance arguments, see Devriese &+  Piessens [ICFP 2011]. Some examples are also available in the+  examples/instance-arguments subdirectory of the Agda distribution.++Irrelevance+-----------++* Dependent irrelevant function types.++  Some examples illustrating the syntax of dependent irrelevant+  function types:++    .(x y : A) → B    .{x y z : A} → B+    ∀ x .y → B        ∀ x .{y} {z} .v → B++  The declaration++    f : .(x : A) → B[x]+    f x = t[x]++  requires that x is irrelevant both in t[x] and in B[x]. This is+  possible if, for instance, B[x] = B′ x, with B′ : .A → Set.++  Dependent irrelevance allows us to define the eliminator for the+  Squash type:++    record Squash (A : Set) : Set where+      constructor squash+      field+        .proof : A++    elim-Squash : {A : Set} (P : Squash A → Set)+                  (ih : .(a : A) → P (squash a)) →+                  (a⁻ : Squash A) → P a⁻+    elim-Squash P ih (squash a) = ih a++  Note that this would not type-check with+  (ih : (a : A) -> P (squash a)).++* Records with only irrelevant fields.++  The following now works:++    record IsEquivalence {A : Set} (_≈_ : A → A → Set) : Set where+      field+        .refl  : Reflexive _≈_+        .sym   : Symmetric _≈_+        .trans : Transitive _≈_++    record Setoid : Set₁ where+      infix 4 _≈_+      field+        Carrier        : Set+        _≈_            : Carrier → Carrier → Set+        .isEquivalence : IsEquivalence _≈_++      open IsEquivalence isEquivalence public++  Previously Agda complained about the application+  IsEquivalence isEquivalence, because isEquivalence is irrelevant and+  the IsEquivalence module expected a relevant argument. Now, when+  record modules are generated for records consisting solely of+  irrelevant arguments, the record parameter is made irrelevant:++    module IsEquivalence {A : Set} {_≈_ : A → A → Set}+                         .(r : IsEquivalence {A = A} _≈_) where+      …++* Irrelevant things are no longer erased internally. This means that+  they are printed as ordinary terms, not as "_" as before.++* The new flag --experimental-irrelevance enables irrelevant universe+  levels and matching on irrelevant data when only one constructor is+  available. These features are very experimental and likely to change+  or disappear.++Reflection+----------++* The reflection API has been extended to mirror features like+  irrelevance, instance arguments and universe polymorphism, and to+  give (limited) access to definitions. For completeness all the+  builtins and primitives are listed below:++    -- Names.++    postulate Name : Set++    {-# BUILTIN QNAME Name #-}++    primitive+      -- Equality of names.+      primQNameEquality : Name → Name → Bool++    -- Is the argument visible (explicit), hidden (implicit), or an+    -- instance argument?++    data Visibility : Set where+      visible hidden instance : Visibility++    {-# BUILTIN HIDING   Visibility #-}+    {-# BUILTIN VISIBLE  visible    #-}+    {-# BUILTIN HIDDEN   hidden     #-}+    {-# BUILTIN INSTANCE instance   #-}++    -- Arguments can be relevant or irrelevant.++    data Relevance : Set where+      relevant irrelevant : Relevance++    {-# BUILTIN RELEVANCE  Relevance  #-}+    {-# BUILTIN RELEVANT   relevant   #-}+    {-# BUILTIN IRRELEVANT irrelevant #-}++    -- Arguments.++    data Arg A : Set where+      arg : (v : Visibility) (r : Relevance) (x : A) → Arg A++    {-# BUILTIN ARG    Arg #-}+    {-# BUILTIN ARGARG arg #-}++    -- Terms.++    mutual+      data Term : Set where+        -- Variable applied to arguments.+        var     : (x : ℕ) (args : List (Arg Term)) → Term+        -- Constructor applied to arguments.+        con     : (c : Name) (args : List (Arg Term)) → Term+        -- Identifier applied to arguments.+        def     : (f : Name) (args : List (Arg Term)) → Term+        -- Different kinds of λ-abstraction.+        lam     : (v : Visibility) (t : Term) → Term+        -- Pi-type.+        pi      : (t₁ : Arg Type) (t₂ : Type) → Term+        -- A sort.+        sort    : Sort → Term+        -- Anything else.+        unknown : Term++      data Type : Set where+        el : (s : Sort) (t : Term) → Type++      data Sort : Set where+        -- A Set of a given (possibly neutral) level.+        set     : (t : Term) → Sort+        -- A Set of a given concrete level.+        lit     : (n : ℕ) → Sort+        -- Anything else.+        unknown : Sort++    {-# BUILTIN AGDASORT            Sort    #-}+    {-# BUILTIN AGDATYPE            Type    #-}+    {-# BUILTIN AGDATERM            Term    #-}+    {-# BUILTIN AGDATERMVAR         var     #-}+    {-# BUILTIN AGDATERMCON         con     #-}+    {-# BUILTIN AGDATERMDEF         def     #-}+    {-# BUILTIN AGDATERMLAM         lam     #-}+    {-# BUILTIN AGDATERMPI          pi      #-}+    {-# BUILTIN AGDATERMSORT        sort    #-}+    {-# BUILTIN AGDATERMUNSUPPORTED unknown #-}+    {-# BUILTIN AGDATYPEEL          el      #-}+    {-# BUILTIN AGDASORTSET         set     #-}+    {-# BUILTIN AGDASORTLIT         lit     #-}+    {-# BUILTIN AGDASORTUNSUPPORTED unknown #-}++    postulate+      -- Function definition.+      Function  : Set+      -- Data type definition.+      Data-type : Set+      -- Record type definition.+      Record    : Set++    {-# BUILTIN AGDAFUNDEF    Function  #-}+    {-# BUILTIN AGDADATADEF   Data-type #-}+    {-# BUILTIN AGDARECORDDEF Record    #-}++    -- Definitions.++    data Definition : Set where+      function     : Function  → Definition+      data-type    : Data-type → Definition+      record′      : Record    → Definition+      constructor′ : Definition+      axiom        : Definition+      primitive′   : Definition++    {-# BUILTIN AGDADEFINITION                Definition   #-}+    {-# BUILTIN AGDADEFINITIONFUNDEF          function     #-}+    {-# BUILTIN AGDADEFINITIONDATADEF         data-type    #-}+    {-# BUILTIN AGDADEFINITIONRECORDDEF       record′      #-}+    {-# BUILTIN AGDADEFINITIONDATACONSTRUCTOR constructor′ #-}+    {-# BUILTIN AGDADEFINITIONPOSTULATE       axiom        #-}+    {-# BUILTIN AGDADEFINITIONPRIMITIVE       primitive′   #-}++    primitive+      -- The type of the thing with the given name.+      primQNameType        : Name → Type+      -- The definition of the thing with the given name.+      primQNameDefinition  : Name → Definition+      -- The constructors of the given data type.+      primDataConstructors : Data-type → List Name++  As an example the expression++    primQNameType (quote zero)++  is definitionally equal to++    el (lit 0) (def (quote ℕ) [])++  (if zero is a constructor of the data type ℕ).++* New keyword: unquote.++  The construction "unquote t" converts a representation of an Agda term+  to actual Agda code in the following way:++  1. The argument t must have type Term (see the reflection API above).++  2. The argument is normalised.++  3. The entire construction is replaced by the normal form, which is+     treated as syntax written by the user and type-checked in the+     usual way.++  Examples:++    test : unquote (def (quote ℕ) []) ≡ ℕ+    test = refl++    id : (A : Set) → A → A+    id = unquote (lam visible (lam visible (var 0 [])))++    id-ok : id ≡ (λ A (x : A) → x)+    id-ok = refl++* New keyword: quoteTerm.++  The construction "quoteTerm t" is similar to "quote n", but whereas+  quote is restricted to names n, quoteTerm accepts terms t. The+  construction is handled in the following way:++  1. The type of t is inferred. The term t must be type-correct.++  2. The term t is normalised.++  3. The construction is replaced by the Term representation (see the+     reflection API above) of the normal form. Any unsolved metavariables+     in the term are represented by the "unknown" term constructor.++  Examples:++    test₁ : quoteTerm (λ {A : Set} (x : A) → x) ≡+            lam hidden (lam visible (var 0 []))+    test₁ = refl++    -- Local variables are represented as de Bruijn indices.+    test₂ : (λ {A : Set} (x : A) → quoteTerm x) ≡ (λ x → var 0 [])+    test₂ = refl++    -- Terms are normalised before being quoted.+    test₃ : quoteTerm (0 + 0) ≡ con (quote zero) []+    test₃ = refl++Compiler backends+=================++MAlonzo+-------++* The MAlonzo backend's FFI now handles universe polymorphism in a+  better way.++  The translation of Agda types and kinds into Haskell now supports+  universe-polymorphic postulates. The core changes are that the+  translation of function types has been changed from++    T[[ Pi (x : A) B ]] =+      if A has a Haskell kind then+        forall x. () -> T[[ B ]]+      else if x in fv B then+        undef+      else+        T[[ A ]] -> T[[ B ]]++  into++    T[[ Pi (x : A) B ]] =+      if x in fv B then+        forall x. T[[ A ]] -> T[[ B ]]  -- Note: T[[A]] not Unit.+      else+        T[[ A ]] -> T[[ B ]],++  and that the translation of constants (postulates, constructors and+  literals) has been changed from++    T[[ k As ]] =+      if COMPILED_TYPE k T then+        T T[[ As ]]+      else+        undef++  into++    T[[ k As ]] =+      if COMPILED_TYPE k T then+        T T[[ As ]]+      else if COMPILED k E then+        ()+      else+        undef.++  For instance, assuming a Haskell definition++    type AgdaIO a b = IO b,++  we can set up universe-polymorphic IO in the following way:++    postulate+      IO     : ∀ {ℓ} → Set ℓ → Set ℓ+      return : ∀ {a} {A : Set a} → A → IO A+      _>>=_  : ∀ {a b} {A : Set a} {B : Set b} →+               IO A → (A → IO B) → IO B++    {-# COMPILED_TYPE IO AgdaIO              #-}+    {-# COMPILED return  (\_ _ -> return)    #-}+    {-# COMPILED _>>=_   (\_ _ _ _ -> (>>=)) #-}++  This is accepted because (assuming that the universe level type is+  translated to the Haskell unit type "()")++    (\_ _ -> return)+      : forall a. () -> forall b. () -> b -> AgdaIO a b+      = T [[ ∀ {a} {A : Set a} → A → IO A ]]++  and++    (\_ _ _ _ -> (>>=))+      : forall a. () -> forall b. () ->+          forall c. () -> forall d. () ->+            AgdaIO a c -> (c -> AgdaIO b d) -> AgdaIO b d+      = T [[ ∀ {a b} {A : Set a} {B : Set b} →+               IO A → (A → IO B) → IO B ]].++Epic+----++* New Epic backend pragma: STATIC.++  In the Epic backend, functions marked with the STATIC pragma will be+  normalised before compilation. Example usage:++    {-# STATIC power #-}++    power : ℕ → ℕ → ℕ+    power 0       x = 1+    power 1       x = x+    power (suc n) x = power n x * x++  Occurrences of "power 4 x" will be replaced by "((x * x) * x) * x".++* Some new optimisations have been implemented in the Epic backend:++  - Removal of unused arguments.++  A worker/wrapper transformation is performed so that unused+  arguments can be removed by Epic's inliner. For instance, the map+  function is transformed in the following way:++    map_wrap : (A B : Set) → (A → B) → List A → List B+    map_wrap A B f xs = map_work f xs++    map_work f []       = []+    map_work f (x ∷ xs) = f x ∷ map_work f xs++  If map_wrap is inlined (which it will be in any saturated call),+  then A and B disappear in the generated code.++  Unused arguments are found using abstract interpretation. The bodies+  of all functions in a module are inspected to decide which variables+  are used. The behaviour of postulates is approximated based on their+  types. Consider return, for instance:++    postulate return : {A : Set} → A → IO A++  The first argument of return can be removed, because it is of type+  Set and thus cannot affect the outcome of a program at runtime.++  - Injection detection.++  At runtime many functions may turn out to be inefficient variants of+  the identity function. This is especially true after forcing.+  Injection detection replaces some of these functions with more+  efficient versions. Example:++    inject : {n : ℕ} → Fin n → Fin (1 + n)+    inject {suc n} zero    = zero+    inject {suc n} (suc i) = suc (inject {n} i)++  Forcing removes the Fin constructors' ℕ arguments, so this function+  is an inefficient identity function that can be replaced by the+  following one:++    inject {_} x = x++  To actually find this function, we make the induction hypothesis+  that inject is an identity function in its second argument and look+  at the branches of the function to decide if this holds.++  Injection detection also works over data type barriers. Example:++    forget : {A : Set} {n : ℕ} → Vec A n → List A+    forget []       = []+    forget (x ∷ xs) = x ∷ forget xs++  Given that the constructor tags (in the compiled Epic code) for+  Vec.[] and List.[] are the same, and that the tags for Vec._∷_ and+  List._∷_ are also the same, this is also an identity function. We+  can hence replace the definition with the following one:++    forget {_} xs = xs++  To get this to apply as often as possible, constructor tags are+  chosen /after/ injection detection has been run, in a way to make as+  many functions as possible injections.++  Constructor tags are chosen once per source file, so it may be+  advantageous to define conversion functions like forget in the same+  module as one of the data types. For instance, if Vec.agda imports+  List.agda, then the forget function should be put in Vec.agda to+  ensure that vectors and lists get the same tags (unless some other+  injection function, which puts different constraints on the tags, is+  prioritised).++  - Smashing.++  This optimisation finds types whose values are inferable at runtime:++    * A data type with only one constructor where all fields are+      inferable is itself inferable.+    * Set ℓ is inferable (as it has no runtime representation).++  A function returning an inferable data type can be smashed, which+  means that it is replaced by a function which simply returns the+  inferred value.++  An important example of an inferable type is the usual propositional+  equality type (_≡_). Any function returning a propositional equality+  can simply return the reflexivity constructor directly without+  computing anything.++  This optimisation makes more arguments unused. It also makes the+  Epic code size smaller, which in turn speeds up compilation.++JavaScript+----------++* ECMAScript compiler backend.++  A new compiler backend is being implemented, targetting ECMAScript+  (also known as JavaScript), with the goal of allowing Agda programs+  to be run in browsers or other ECMAScript environments.++  The backend is still at an experimental stage: the core language is+  implemented, but many features are still missing.++  The ECMAScript compiler can be invoked from the command line using+  the flag --js:++    agda --js --compile-dir=<DIR> <FILE>.agda++  Each source <FILE>.agda is compiled into an ECMAScript target+  <DIR>/jAgda.<TOP-LEVEL MODULE NAME>.js. The compiler can also be+  invoked using the Emacs mode (the variable agda2-backend controls+  which backend is used).++  Note that ECMAScript is a strict rather than lazy language. Since+  Agda programs are total, this should not impact program semantics,+  but it may impact their space or time usage.++  ECMAScript does not support algebraic datatypes or pattern-matching.+  These features are translated to a use of the visitor pattern. For+  instance, the standard library's List data type and null function+  are translated into the following code:++    exports["List"] = {};+    exports["List"]["[]"] = function (x0) {+        return x0["[]"]();+      };+    exports["List"]["_∷_"] = function (x0) {+        return function (x1) {+          return function (x2) {+            return x2["_∷_"](x0, x1);+          };+        };+      };++    exports["null"] = function (x0) {+        return function (x1) {+          return function (x2) {+            return x2({+              "[]": function () {+                return jAgda_Data_Bool["Bool"]["true"];+              },+              "_∷_": function (x3, x4) {+                return jAgda_Data_Bool["Bool"]["false"];+              }+            });+          };+        };+      };++  Agda records are translated to ECMAScript objects, preserving field+  names.++  Top-level Agda modules are translated to ECMAScript modules,+  following the common.js module specification. A top-level Agda+  module "Foo.Bar" is translated to an ECMAScript module+  "jAgda.Foo.Bar".++  The ECMAScript compiler does not compile to Haskell, so the pragmas+  related to the Haskell FFI (IMPORT, COMPILED_DATA and COMPILED) are+  not used by the ECMAScript backend. Instead, there is a COMPILED_JS+  pragma which may be applied to any declaration. For postulates,+  primitives, functions and values, it gives the ECMAScript code to be+  emitted by the compiler. For data types, it gives a function which+  is applied to a value of that type, and a visitor object. For+  instance, a binding of natural numbers to ECMAScript integers+  (ignoring overflow errors) is:++    data ℕ : Set where+      zero : ℕ+      suc  : ℕ → ℕ++    {-# COMPILED_JS ℕ function (x,v) {+        if (x < 1) { return v.zero(); } else { return v.suc(x-1); }+      } #-}+    {-# COMPILED_JS zero 0 #-}+    {-# COMPILED_JS suc function (x) { return x+1; } #-}++    _+_ : ℕ → ℕ → ℕ+    zero  + n = n+    suc m + n = suc (m + n)++    {-# COMPILED_JS _+_ function (x) { return function (y) {+                          return x+y; };+      } #-}++  To allow FFI code to be optimised, the ECMAScript in a COMPILED_JS+  declaration is parsed, using a simple parser that recognises a pure+  functional subset of ECMAScript, consisting of functions, function+  applications, return, if-statements, if-expressions,+  side-effect-free binary operators (no precedence, left associative),+  side-effect-free prefix operators, objects (where all member names+  are quoted), field accesses, and string and integer literals.+  Modules may be imported using the require("<module-id>") syntax: any+  impure code, or code outside the supported fragment, can be placed+  in a module and imported.++Tools+=====++* New flag --safe, which can be used to type-check untrusted code.++  This flag disables postulates, primTrustMe, and "unsafe" OPTION+  pragmas, some of which are known to make Agda inconsistent.++  Rejected pragmas:++    --allow-unsolved-metas+    --experimental-irrelevance+    --guardedness-preserving-type-construtors+    --injective-type-constructors+    --no-coverage-check+    --no-positivity-check+    --no-termination-check+    --sized-types+    --type-in-type++  Note that, at the moment, it is not possible to define the universe+  level or coinduction primitives when --safe is used (because they+  must be introduced as postulates). This can be worked around by+  type-checking trusted files in a first pass, without using --safe,+  and then using --safe in a second pass. Modules which have already+  been type-checked are not re-type-checked just because --safe is+  used.++* Dependency graphs.++  The new flag --dependency-graph=FILE can be used to generate a DOT+  file containing a module dependency graph. The generated file (FILE)+  can be rendered using a tool like dot.++* The --no-unreachable-check flag has been removed.++* Projection functions are highlighted as functions instead of as+  fields. Field names (in record definitions and record values) are+  still highlighted as fields.++* Support for jumping to positions mentioned in the information+  buffer has been added.++* The "make install" command no longer installs Agda globally (by+  default).

src/data/EpicInclude/AgdaPrelude.e view

@@ -2,11 +2,12 @@  -- IO +{- %inline putStr (x:String) -> Unit =-    foreign Unit "putStr" (x:String)+    foreign Unit "wputStr" (x:String)  putStrLn (x:String) -> Unit =-    putStr(append(x,"\n"))+    putStr(primStringAppend(x,"\n"))  readStr () -> String =     foreign String "readStr" ()@@ -19,85 +20,172 @@  printInt (x:Int) -> Unit =     foreign Unit "printInt" (x:Int)+-}  ioreturn (a : Any, u : Unit) -> Any = a-iobind (x : Any, f : Any, u : Unit) -> Any = f (x (u), u)+iobind (x : Any, f : Any, u : Unit) -> Any = %effect (let v : Any = %effect (x(u)) in f (v, u))  -- String operations -append (x:String, y:String) -> String =-    foreign String "append" (x:String, y:String)+-- data String = Con 0 | Con 1 (Char*) String -length (x:String) -> String =-    foreign Int "strlen" (x:String)+freadStr (stream : Ptr) -> Data =+    let isEof : Bool = foreign Int "feof" (stream : Ptr)+     in if isEof then Con 0 ()+                 else let str : String = %effect(foreign String "freadStrChunk" (stream : Ptr))+                       in Con 1 ( str , freadStr (stream)) -index (x:String, i:Int) -> Char =-    foreign Int "strIndex" (x:String, i:Int)+readStr (u : Unit) -> Data =+    let isEof : Bool = foreign Int "eofstdin" ()+     in if isEof then Con 0 ()+                 else let str : String = %effect(foreign String "readStrChunk" ())+                       in Con 1 ( str , readStr (u)) +primStringAppend (xs : Data, ys : Data) -> Data = case xs of+  { Con 0 ()                        -> ys+  | Con 1 (x : String, rest : Data) -> Con 1 (x, primStringAppend (rest, ys))+  }++length (xs : Data) -> Int = case xs of+  { Con 0 () -> 0+  | Con 1 (x : String, rest : Data) -> strlen(x) + length(rest)+  }++charAt (xs : Data, i : Int) -> Int = case xs of+  { Con 0 () -> error "index: out of bounds!"+  | Con 1 (x : String, rest : Data) -> +    let len : Int = strlen(x)+     in (if i < len then foreign Int "strIndex" (x : String, i : Int)+                    else charAt (rest, i - len))+  }++mkString (xs : Data) -> String = case xs of+  { Con 0 () -> ""+  | Con 1 (s : String , rest : Data) -> +    let rs : String = mkString (rest) in+    {-let rsLen : Int = strlen (rs) in+    if rsLen == 0 then s else-} foreign String "append" (s : String, rs : String)+  }++frString( xs : String) -> Data = Con 1 (xs , Con 0 ())++primStringEquality (xs : Data, ys : Data) -> Bool =+    foreign Int "eqString" (mkString(xs) : String, mkString(ys) : String)++charToString (c : Int) -> Data = +    Con 1 (charToStr(c), Con 0 ())+charToStr (c : Int) -> String = +    foreign String "charToStr" (c : Int)++strlen (s : String) -> Int = foreign Int "strlen" (s : String)++-- TODO: toList/fromList could be made slightly more efficient.++primStringToListS (xs : String) -> Data = %effect(+    let result : Data = primNil ()     in+    let i      : Int  = strlen (xs) - 1 in+    %while (i >= 0,+       let ! result = primCons (foreign Int "strIndex" (xs : String, i : Int), result) in+       let ! i      = i - 1 in+       unit) ;+    result)++primStringToList (xs : Data) -> Data = case xs of+  { Con 0 () -> primNil ()+  | Con 1 (str : String, rest : Data) -> primListAppend(primStringToListS(str), primStringToList(rest))+  }++map (f : Any, l : Any) -> Any = case l of+  { Con 0 () -> Con 0 ()+  | Con 1 (x : Any, xs : Any) -> Con 1 (f (x), map (f, xs))+  }++primStringFromList (l : Data) -> String = map (charToStr, l)+++strCons(i : Int , s : String) -> String =+   foreign String "strCons" (i : Int, s : String)++-- Lists++primNil () -> Data = Con 0 ()++primCons(x : Any , xs : Data) -> Data = Con 1 (x, xs)++listElim (op : Any, z : Any, xs : Data) -> Any = case xs of+  { Con 0 () -> z+  | Con 1 (y : Any, ys : Data) -> op (y, listElim(op, z, ys))+  }++primListAppend (xs : Data, ys : Data) -> Data = listElim(primCons, ys, xs) -- Big number arithmetic  subBig (x:BigInt, y:BigInt) -> BigInt =-   foreign BigInt "subBigInt" (x:BigInt, y:BigInt)+   foreign BigInt "subBig" (x:BigInt, y:BigInt)  gtBig (x:BigInt, y:BigInt) -> Bool =-   foreign Int "gtBigInt" (x:BigInt, y:BigInt)+   foreign Int "gtBig" (x:BigInt, y:BigInt)  leBig (x:BigInt, y:BigInt) -> Bool =-   foreign Int "leBigInt" (x:BigInt, y:BigInt)+   foreign Int "leBig" (x:BigInt, y:BigInt)  geBig (x:BigInt, y:BigInt) -> Bool =-   foreign Int "geBigInt" (x:BigInt, y:BigInt)+   foreign Int "geBig" (x:BigInt, y:BigInt)  printBig (x:BigInt) -> Unit =-   foreign Unit "printBigInt" (x:BigInt)+   foreign Unit "printBig" (x:BigInt) -bigIntToStr (x:BigInt) -> String =-    foreign String "bigIntToStr" (x:BigInt)+bigToStr (x:BigInt) -> Data =+    frString(foreign String "bigToStr" (x:BigInt)) -strToBigInt (x:String) -> Int =-    foreign String "strToBigInt" (x:String)+strToBig (x : Data) -> Any = foreign BigInt "strToBig" (mkString(x) : String) +-- strToBig (x:String) -> Any =+--    foreign Any "strToBig" (x:String)++bigToInt (x : BigInt) -> Int =+    foreign Int "bigToInt" (x : BigInt)+ -- Unit  %inline primUnit() -> Unit = unit  -- Nats -primNatPlus (x:BigInt, y:BigInt) -> BigInt =-   foreign BigInt "addBigInt" (x:BigInt, y:BigInt)+primNatPlus (x:Any, y:Any) -> Any =+   foreign Any "addBig" (x:Any, y:Any) -primNatTimes (x:BigInt, y:BigInt) -> BigInt =-   foreign BigInt "mulBigInt" (x:BigInt, y:BigInt)+primNatTimes (x:Any, y:Any) -> Any =+   foreign Any "mulBig" (x:Any, y:Any) -primZero() -> BigInt = 0L+%inline primNatMinus(x : Any, y : Any) -> Any = atLeastZeroBig(subBig(x, y)) -primSuc (n : BigInt) -> BigInt = primNatPlus(n, 1L) -primPred(n : BigInt) -> BigInt = subBig(n, 1L) -%inline absBig (x : BigInt) -> BigInt = +primZero() -> Any = foreign BigInt "bigZero" ()+primOne() -> Any  = foreign BigInt "bigOne" ()++primSuc (n : Any) -> Any = primNatPlus(n, primOne())++primPred(n : Any) -> Any = subBig(n, primOne())++%inline atLeastZeroBig (x : Any) -> Any =    if primNatLess(x, primZero)       then primZero      else x -%inline primNatMinus(x : BigInt, y : BigInt) -> BigInt = absBig(subBig(x, y))+primNatModSucAux(k : BigInt, m : BigInt, n : BigInt, j : BigInt) -> BigInt =+    foreign BigInt "modBig" (n : BigInt, m : BigInt) --- readInt () -> Int = foreign Int "readInt" () + primNatEquality (x:BigInt, y:BigInt) -> Bool =-    foreign Int "eqBigInt" (x:BigInt, y:BigInt)+    foreign Int "eqBig" (x:BigInt, y:BigInt)  primNatLess (x:BigInt, y:BigInt) -> Bool =-    foreign Int "ltBigInt" (x:BigInt, y:BigInt)+    foreign Int "ltBig" (x:BigInt, y:BigInt) --- Strings --- Cannot call foreign "append" directly, for some reason-%inline primStringAppend (x : String, y : String) -> String = append(x, y)--primStringEquality (x : String, y : String) -> Bool =-    foreign Int "eqString" (x : String, y : String)- -- Bools  %inline primTrue  () -> Bool = true@@ -109,9 +197,33 @@ printChar (x:Int) -> Unit =     foreign Unit "printCharRep" (x:Int) -init () -> Unit =-    foreign Unit "init" ()+%inline primCharEquality (c1 : Int, c2 : Int) -> Bool = c1 == c2 +primCharToNat (c : Int) -> BigInt = foreign BigInt "NEWBIGINTVALI" (c : Int)+++-- Floats+floatToStr (x : Float) -> String =+    foreign String "floatToStr" (x : Float)++strToFloat (s : String) -> Float =+    foreign Float "strToFloat" (s : String)+ -- Coinduction  primSharp (u1 : Any, u2 : Any, x : Any) -> Data = Con 0 (x)++-- RUNTIME++init () -> Unit =+    foreign Unit "init" ()+    +-- Levels++primLevelMax  (x : Any, y : Any) -> Any = 0L -- error "primLevelMax"+primLevelZero () -> Any = 0L -- error "primLevelZero"+primLevelSuc  (x : Any) -> Any = primSuc(x) -- error "primLevelSuc"++-- TrustMe++primTrustMe (a : Unit, x : Any, y : Any) -> Any = Con 0 ()

src/data/EpicInclude/stdagda.c view

@@ -6,17 +6,28 @@ #include <sys/time.h> #include <locale.h> //#include "closure.h"-#include "stdfuns.h" + #define _UNICODE #define UNICODE +void wputStr(char* s) { wprintf(L"%s",s); }+ int eqString(char *x, char *y) {     return strcmp(x, y) == 0; } +VAL bigZeroRep;+VAL bigOneRep;++VAL bigZero() { return bigZeroRep;}+VAL bigOne() {return bigOneRep;}+ void init(void) {   setlocale(LC_CTYPE, "");++  bigZeroRep = NEWBIGINTVALI(0);+  bigOneRep  = NEWBIGINTVALI(1); }  void printCharRep(int c) {@@ -24,21 +35,61 @@   wprintf(L"%lc", c); } -int bigToInt(mpz_t* n) {-  return (int) mpz_get_si(*n);+int bigToInt(VAL n) {+  return (int) mpz_get_si(*(GETBIGINT(n))); } -mpz_t* intToBig(int n) {-  mpz_t* answer = EMALLOC(sizeof(mpz_t));-  mpz_init(*answer);-  mpz_set_si(*answer, (signed long int)n);-  return answer; +VAL intToBig(int n) {+  return NEWBIGINTVALI(n); }  -VAL getArgBig(mpz_t* num) {+VAL getArgBig(VAL num) {   return evm_getArg(bigToInt(num)); } -mpz_t* numArgsBig(void) { -  return intToBig(epic_numArgs());+VAL numArgsBig(void) { +  return NEWBIGINTVALI(epic_numArgs());+}++char* charToStr(int x)+{+    char* buf = EMALLOC(2*sizeof(char));+    buf[0] = (char)x; buf[1] = '\0';+    return buf;+}++int eof() { return EOF; }++int charAtBig(char* str, VAL n)+{+    return (int)str[bigToInt(n)];+}++int charAt(char* str, int n) { return (int)str[n]; }++#define STRING_BUFFER_SIZE 1024++int eofstdin() { return feof(stdin);}++char* readStrChunk() { return freadStrChunk(stdin); }++char* freadStrChunk(FILE* f) {+  char* in = EMALLOC(sizeof(char)*STRING_BUFFER_SIZE);+  fgets(in,STRING_BUFFER_SIZE,f);+  return in;+}++void** newArray(VAL size)+{+  return EMALLOC(sizeof(void*)*bigToInt(size));+}++void* arrayIndex(void** array, VAL i)+{+  return array[bigToInt(i)];+}++void setArrayIndex(void** array, VAL i, void* val)+{+  array[bigToInt(i)] = val; }

src/data/EpicInclude/stdagda.h view

@@ -11,11 +11,31 @@ #include <gc/gc.h> #include <gmp.h> #include <stdio.h>+#include "stdfuns.h" void init(void); int eqString(char *x, char *y); void printCharRep(int c); -char* getArgv(mpz_t* n);-mpz_t* getArgc(void);+void wputStr(char* s);++int bigToInt(VAL n);+VAL intToBig(int n);++VAL getArgBig(VAL num);++VAL numArgsBig(void);++FILE* getStdin (void);+FILE* getStdout(void);+++char* charToStr(int x);+int charAt(char* str, int n);+int charAtBig(char* str, VAL n);++int eof();++char* freadStrChunk(FILE* f);+// void* freadStrChunk(void* h);  #endif

src/data/emacs-mode/agda-input.el view

@@ -41,6 +41,13 @@             (list (string c))))    (string-to-list s))) +(defun agda-input-character-range (from to)+  "A string consisting of the characters from FROM to TO."+  (let (seq)+    (dotimes (i (1+ (- to from)))+      (setq seq (cons (+ from i) seq)))+    (concat (nreverse seq))))+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; Functions used to tweak translation pairs @@ -383,6 +390,9 @@   ("d-|"  . ("↧"))  ("dd-" . ("↡"))   ("ud-|" . ("↨")) +  ("l->" . ("↢"))+  ("r->" . ("↣"))+   ("dz" . ("↯"))    ;; Ellipsis.@@ -468,8 +478,8 @@    ;; Parentheses. -  ("(" . ,(agda-input-to-string-list "([{⁅⁽₍〈⎴⟦⟨⟪〈《「『【〔〖〚︵︷︹︻︽︿﹁﹃﹙﹛﹝（［｛｢"))-  (")" . ,(agda-input-to-string-list ")]}⁆⁾₎〉⎵⟧⟩⟫〉》」』】〕〗〛︶︸︺︼︾﹀﹂﹄﹚﹜﹞）］｝｣"))+  ("(" . ,(agda-input-to-string-list "([{⁅⁽₍〈⎴⟅⟦⟨⟪⦃〈《「『【〔〖〚︵︷︹︻︽︿﹁﹃﹙﹛﹝（［｛｢"))+  (")" . ,(agda-input-to-string-list ")]}⁆⁾₎〉⎵⟆⟧⟩⟫⦄〉》」』】〕〗〛︶︸︺︼︾﹀﹂﹄﹚﹜﹞）］｝｣"))    ("[[" . ("⟦"))   ("]]" . ("⟧"))@@ -477,7 +487,15 @@   (">"  . ("⟩"))   ("<<" . ("⟪"))   (">>" . ("⟫"))+  ("{{" . ("⦃"))+  ("}}" . ("⦄")) +  ("(b" . ("⟅"))+  (")b" . ("⟆"))++  ("lbag" . ("⟅"))+  ("rbag" . ("⟆"))+   ;; Primes.    ("'" . ,(agda-input-to-string-list "′″‴⁗"))@@ -519,6 +537,29 @@                                                ⍉⍊⍋⍌⍍⍎⍏⍐⍑⍒⍓⍔⍕⍖⍗⍘⍙⍚⍛                                                ⍜⍝⍞⍟⍠⍡⍢⍣⍤⍥⍦⍧⍨⍩⍪⍫⍬⍭⍮                                                ⍯⍰⍱⍲⍳⍴⍵⍶⍷⍸⍹⍺⎕"))++  ;; Some combining characters.+  ;;+  ;; The following combining characters also have (other)+  ;; translations:+  ;; ̀ ́ ̂ ̃ ̄ ̆ ̇ ̈ ̋ ̌ ̣ ̧ ̱++  ("^--" . ,(agda-input-to-string-list"̅̿"))+  ("_--" . ,(agda-input-to-string-list"̲̳"))+  ("^~"  . ,(agda-input-to-string-list"̃͌"))+  ("_~"  .  (                         "̰"))+  ("^."  . ,(agda-input-to-string-list"̇̈⃛⃜"))+  ("_."  . ,(agda-input-to-string-list"̣̤"))+  ("^l"  . ,(agda-input-to-string-list"⃖⃐⃔"))+  ("^l-" .  (                         "⃖"))+  ("^r"  . ,(agda-input-to-string-list"⃗⃑⃕"))+  ("^r-" .  (                         "⃗"))+  ("^lr" .  (                         "⃡"))+  ("_lr" .  (                         "͍"))+  ("^^"  . ,(agda-input-to-string-list"̂̑͆"))+  ("_^"  . ,(agda-input-to-string-list"̭̯̪"))+  ("^v"  . ,(agda-input-to-string-list"̌̆"))+  ("_v"  . ,(agda-input-to-string-list"̬̮̺"))    ;; Shorter forms of many greek letters plus ƛ.

src/data/emacs-mode/agda2-highlight.el view

@@ -356,12 +356,14 @@   (font-lock-mode 0)   (setq annotation-bindings agda2-highlight-faces)) -(defun agda2-highlight-load (file)-  "Load syntax highlighting information from FILE."+(defun agda2-highlight-load (file &optional keep)+  "Load syntax highlighting information from FILE.+Old syntax highlighting information is first removed, unless KEEP+is non-nil."   (let ((coding-system-for-read 'utf-8)         ;; Ignore read-only status, otherwise this function may fail.         (inhibit-read-only t))-    (annotation-load-file file (lambda (anns) t)+    (annotation-load-file file (lambda (anns) (not keep))                           "Click mouse-2 to jump to definition")))  (defun agda2-highlight-clear nil

src/data/emacs-mode/agda2-mode.el view

@@ -10,7 +10,7 @@  ;;; Code: -(defvar agda2-version "2.2.10"+(defvar agda2-version "2.3.0"   "The version of the Agda mode. Note that, by default, the same version of the underlying Haskell library is used (see `agda2-ghci-options').")@@ -89,7 +89,8 @@   "MAlonzo"   "The backend which is used to compile Agda programs."   :type '(choice (const "MAlonzo")-                 (const "Epic"))+                 (const "Epic")+                 (const "JS"))   :group 'agda2)  (defcustom agda2-ghci-options@@ -626,6 +627,22 @@     (goto-char p1))   (agda2-load)) +(defun agda2-make-case-action-extendlam (newcls)+  "Replace definition of extended lambda with new clauses NEWCLS and reload."+  (agda2-forget-all-goals);; we reload later anyway.+  (let* ((p (+ (re-search-backward "\\({[^!]\\)\\|;") 1))+         cl)+    (goto-char p)+    (delete-region p (- (re-search-forward "\\([^!]}\\)\\|;") 1))+    (goto-char p)+    (insert "  ")+    (goto-char (+ p 1))+    (while (setq cl (pop newcls))+      (insert cl)+      (if newcls (insert " ; ")))+    (goto-char p))+  (agda2-load))+ (defun agda2-status-action (status)   "Display the string STATUS in the current buffer's mode line. \(precondition: the current buffer has to use the Agda mode as the@@ -641,6 +658,24 @@     (insert text)     (set-syntax-table agda2-mode-syntax-table)     (set-input-method "Agda")++    ;; Support for jumping to positions mentioned in the text.+    (set (make-local-variable 'compilation-error-regexp-alist)+         '(("\\([\\\\/][^[:space:]]*\\):\\([0-9]+\\),\\([0-9]+\\)-\\(\\([0-9]+\\),\\)?\\([0-9]+\\)"+            1 (2 . 5) (3 . 6))))+    ;; No support for recompilation. An attempt to recompile via the+    ;; info buffer (using "g") will (most likely) lead to a (dynamic)+    ;; type error. (The default is to run "make -k".)+    (set (make-local-variable 'compile-command)+         'agda2-does-not-support-compilation-via-the-compilation-minor-mode)+    (compilation-minor-mode 1)++    ;; The info buffer is read-only. Compilation minor mode introduces+    ;; the keybindings "g" (recompile) and "q" (bury the buffer), and+    ;; these keybindings can make it rather awkward to edit the info+    ;; buffer. To avoid surprises we make the buffer read-only.+    (setq buffer-read-only t)+     (goto-char (point-min))     (put-text-property 0 (length name) 'face '(:weight bold) name)     (setq mode-line-buffer-identification name)@@ -849,6 +884,10 @@                     (agda2-string-quote highlighting)))       (delete-file highlighting)))) +(defun agda2-literate-p ()+  "Is the current buffer a literate Agda buffer?"+  (equal (file-name-extension (buffer-name)) "lagda"))+ (defun agda2-goals-action (goals)   "Annotates the goals in the current buffer with text properties. GOALS is a list of the buffer's goal numbers, in the order in@@ -858,9 +897,10 @@ ways."   (agda2-forget-all-goals)   (agda2-let-      (stk+      ((literate (agda2-literate-p))+       stk        top)-      ((delims() (re-search-forward "[?]\\|[{][-!]\\|[-!][}]\\|--" nil t))+      ((delims() (re-search-forward "[?]\\|[{][-!]\\|[-!][}]\\|--\\|\\\\begin{code}\\|\\\\end{code}" nil t))        (is-lone-questionmark ()           (save-excursion             (save-match-data@@ -869,24 +909,33 @@                  "\\(.[{(]\\|.\\s \\)[?]\\(\\s \\|[)};]\\|$\\)"))))        (make(p)  (agda2-make-goal p (point) (pop goals)))        (inside-comment() (and stk (null     (car stk))))-       (inside-goal()    (and stk (integerp (car stk)))))+       (inside-goal()    (and stk (integerp (car stk))))+       (outside-code()   (and stk (eq (car stk) 'outside)))+       (inside-code()    (not (outside-code))))     (save-excursion+      ;; In literate mode we should start out in the "outside of code"+      ;; state.+      (if literate (push 'outside stk))       (goto-char (point-min))       (while (and goals (delims))         (labels ((c (s) (equal s (match-string 0))))           (cond-           ((c "--") (when (not stk)              (end-of-line)))-           ((c "{-") (when (not (inside-goal))    (push nil           stk)))-           ((c "{!") (when (not (inside-comment)) (push (- (point) 2) stk)))-           ((c "-}") (when (inside-comment) (pop stk)))-           ((c "!}") (when (inside-goal)-                       (setq top (pop stk))-                       (unless stk (make top))))-           ((c "?")  (progn-                       (when (and (not stk) (is-lone-questionmark))-                         (delete-char -1)-                         (insert "{!!}")-                         (make (- (point) 4)))))))))))+           ((c "\\begin{code}") (when (outside-code)               (pop stk)))+           ((c "\\end{code}")   (when (not stk)                    (push 'outside stk)))+           ((c "--")            (when (not stk)                    (end-of-line)))+           ((c "{-")            (when (and (inside-code)+                                           (not (inside-goal)))    (push nil           stk)))+           ((c "-}")            (when (inside-comment)             (pop stk)))+           ((c "{!")            (when (and (inside-code)+                                           (not (inside-comment))) (push (- (point) 2) stk)))+           ((c "!}")            (when (inside-goal)+                                  (setq top (pop stk))+                                  (unless stk (make top))))+           ((c "?")             (progn+                                  (when (and (not stk) (is-lone-questionmark))+                                    (delete-char -1)+                                    (insert "{!!}")+                                    (make (- (point) 4)))))))))))  (defun agda2-make-goal (p q n)   "Make a goal with number N at <P>{!...!}<Q>.  Assume the region is clean."@@ -982,12 +1031,14 @@     (append (format "\\x%x\\&" (encode-char c 'ucs)) nil)))  (defun agda2-string-quote (s)-  "Convert string S into a string representing it in Haskell syntax.-Escape newlines, double quotes, etc.. in the string S, add-surrounding double quotes, and convert non-ASCII characters to the \\xNNNN-notation used in Haskell strings."-  (let ((pp-escape-newlines t))-    (mapconcat 'agda2-char-quote (pp-to-string s) "")))+  "Format S as a Haskell string literal.+Removes any text properties, escapes newlines, double quotes,+etc., adds surrounding double quotes, and converts non-ASCII+characters to the \\xNNNN notation used in Haskell strings."+  (let ((pp-escape-newlines t)+        (s2 (copy-sequence s)))+    (set-text-properties 0 (length s2) nil s2)+    (mapconcat 'agda2-char-quote (pp-to-string s2) "")))  (defun agda2-list-quote (strings)   "Convert a list of STRINGS into a string representing it in Haskell syntax."

src/data/emacs-mode/annotation.el view

@@ -82,7 +82,7 @@   (incf start annotations-offset)   (incf end annotations-offset)   (when (and (<= (point-min) start)-             (<= start end)+             (< start end)              (<= end (point-max)))     (let ((faces (delq nil                        (mapcar (lambda (ann)@@ -104,9 +104,16 @@         (add-to-list 'props 'mouse-face)         (add-to-list 'props 'help-echo))       (when props-        (add-text-properties start end-                             `(annotation-annotated   t-                               annotation-annotations ,props))))))+        (let ((pos start)+              mid)+          (while (< pos end)+            (setq mid (next-single-property-change pos+                         'annotation-annotations nil end))+            (let* ((old-props (get-text-property pos 'annotation-annotations))+                   (all-props (union old-props props)))+              (add-text-properties pos mid+                 `(annotation-annotated t annotation-annotations ,all-props))+              (setq pos mid))))))))  (defmacro annotation-preserve-mod-p-and-undo (&rest code)   "Run CODE preserving both the undo data and the modification bit."

src/full/Agda/Auto/Auto.hs view

@@ -31,7 +31,6 @@ import Agda.Syntax.Common import Agda.Syntax.Translation.InternalToAbstract import Agda.Syntax.Translation.AbstractToConcrete (abstractToConcrete, abstractToConcrete_, makeEnv, runAbsToCon, toConcrete)-import Agda.Interaction.Monad import Agda.Interaction.BasicOps hiding (refine) import Agda.Interaction.MakeCase (findClause) import Agda.TypeChecking.Reduce (normalise)@@ -116,10 +115,10 @@                         if listmode then do                         nsol' <- readIORef nsol-                        when (nsol' <= 10) $ mapM (\(m, _, _, _) -> frommy (Meta m)) (Map.elems tccons) >>= \trms -> modifyIORef sols (trms :)+                        when (nsol' <= 10) $ runErrorT (mapM (\(m, _, _, _) -> frommy (Meta m)) (Map.elems tccons)) >>= \trms -> case trms of {Left{} -> writeIORef nsol $! nsol' + 1; Right trms -> modifyIORef sols (trms :)}                        else do                         nsol' <- readIORef nsol-                        when (nsol' == 1) $ mapM (\(m, _, _, _) -> frommy (Meta m)) (Map.elems tccons) >>= \trms -> writeIORef sols [trms]+                        when (nsol' == 1) $ runErrorT (mapM (\(m, _, _, _) -> frommy (Meta m)) (Map.elems tccons)) >>= \trms -> case trms of {Left{} -> writeIORef nsol $! nsol' + 1; Right trms -> writeIORef sols [trms]}                ticks <- liftIO $ newIORef 0                let exsearch initprop recinfo defdfv = liftIO $ System.Timeout.timeout (timeout * 1000000) (                     let r d = do@@ -296,19 +295,22 @@                     in r 0)                  case sols of                   Just (cls : _) -> withInteractionId ii $ do-                   cls' <- liftIO $ mapM frommyClause cls-                   cls'' <- mapM (\(I.Clause _ tel perm ps body) ->-                     withCurrentModule (AN.qnameModule def) $ do-                      -- Normalise the dot patterns-                      ps <- addCtxTel tel $ normalise ps-                      body <- etaContractBody body-                      liftM modifyAbstractClause $ inContext [] $ reify $ NamedClause def $ I.Clause noRange tel perm ps body-                    ) cls'-                   pcs <- withInteractionId ii $ mapM prettyA cls''-                   ticks <- liftIO $ readIORef ticks+                   cls' <- liftIO $ runErrorT (mapM frommyClause cls)+                   case cls' of+                    Left{} -> dispmsg "No solution found"+                    Right cls' -> do+                     cls'' <- mapM (\(I.Clause _ tel perm ps body) ->+                       withCurrentModule (AN.qnameModule def) $ do+                        -- Normalise the dot patterns+                        ps <- addCtxTel tel $ normalise ps+                        body <- etaContractBody body+                        liftM modifyAbstractClause $ inContext [] $ reify $ NamedClause def $ I.Clause noRange tel perm ps body+                      ) cls'+                     pcs <- withInteractionId ii $ mapM prettyA cls''+                     ticks <- liftIO $ readIORef ticks  -                   return (Right $ Left (map (insertAbsurdPattern . PP.renderStyle (PP.style { PP.mode = PP.OneLineMode })) pcs), Nothing)+                     return (Right $ Left (map (insertAbsurdPattern . PP.renderStyle (PP.style { PP.mode = PP.OneLineMode })) pcs), Nothing)                    Just [] -> dispmsg "No solution found" -- case not possible at the moment because case split doesnt care about search exhaustiveness                   Nothing -> dispmsg $ "No solution found at time out (" ++ show timeout ++ "s)"

src/full/Agda/Auto/CaseSplit.hs view

@@ -181,7 +181,7 @@                          if elem scrut mblkvar then costCaseSplitLow else (if scrut < length ctx - nscrutavoid && nothid then costCaseSplitHigh else costCaseSplitVeryHigh)                   nothid = let HI hid _ = ctx !! scrut-                          in case hid of {Hidden -> False; NotHidden -> True}+                          in case hid of {Hidden -> False; Instance -> False; NotHidden -> True}                sols <- rc (depth - cost) (length ctx - 1 - scrut) ctx2 tt2 pats2

src/full/Agda/Auto/Convert.hs view

@@ -5,6 +5,7 @@ import Agda.Utils.Impossible #include "../undefined.h" +import Control.Applicative hiding (getConst, Const(..)) import Data.IORef import Data.Map (Map) import qualified Data.Map as Map@@ -21,11 +22,13 @@ import Agda.TypeChecking.Monad.Signature (getConstInfo, getDefFreeVars, getImportedSignature) import Agda.Utils.Permutation (Permutation(Perm), idP, permute, takeP) import Agda.Interaction.BasicOps (rewrite, Rewrite(..))+import Agda.TypeChecking.Level (reallyUnLevelView) import Agda.TypeChecking.Monad.Base (mvJudgement, mvPermutation, getMetaInfo, ctxEntry, envContext, clEnv, Judgement(HasType)) import Agda.TypeChecking.Monad.MetaVars (lookupMeta, withMetaInfo) import Agda.TypeChecking.Monad.Context (getContextArgs)-import Agda.TypeChecking.Monad.Constraints (lookupConstraint, getConstraints)+import Agda.TypeChecking.Monad.Constraints (getAllConstraints) import Agda.TypeChecking.Substitute (piApply, raise)+import qualified Agda.TypeChecking.Substitute as I (absBody) import Agda.TypeChecking.Reduce (Normalise, normalise, instantiate) import Agda.TypeChecking.EtaContract (etaContract) import Agda.TypeChecking.Primitive (constructorForm)@@ -81,12 +84,11 @@      typ <- lift $ norm typ      typ' <- tomyType typ      let clausesToDef clauses = do-           let clauses' = map I.translatedClause clauses-           clauses'' <- tomyClauses clauses'-           let narg = case clauses' of+           clauses' <- tomyClauses clauses+           let narg = case clauses of                         [] -> 0                         I.Clause {I.clausePats = xs} : _ -> length xs-           return (Def narg clauses'' Nothing Nothing, [])+           return (Def narg clauses' Nothing Nothing, [])      (cont, projfcns2) <- case defn of       MB.Axiom {} -> return (Postulate, [])       MB.Function {MB.funClauses = clauses} -> clausesToDef clauses@@ -96,10 +98,11 @@        cons2 <- mapM (\con -> getConst True con TMAll) cons        return (Datatype cons2 [], [])       MB.Record {MB.recFields = fields, MB.recTel = tel} -> do -- the value of recPars seems unreliable or don't know what it signifies-       let pars n (I.El _ (I.Pi it (I.Abs _ typ))) = C.Arg (C.argHiding it) (C.argRelevance it) (I.Var n []) : pars (n - 1) typ+       let pars n (I.El _ (I.Pi it typ)) = C.Arg (C.argHiding it) (C.argRelevance it) (I.Var n []) : pars (n - 1) (I.unAbs typ)            pars _ (I.El _ _) = []            contyp npar I.EmptyTel = I.El (I.mkType 0 {- arbitrary -}) (I.Def cn (pars (npar - 1) typ))            contyp npar (I.ExtendTel it (I.Abs v tel)) = I.El (I.mkType 0 {- arbitrary -}) (I.Pi it (I.Abs v (contyp (npar + 1) tel)))+           contyp npar (I.ExtendTel it I.NoAbs{})     = __IMPOSSIBLE__        contyp' <- tomyType $ contyp 0 tel        cc <- lift $ liftIO $ readIORef c        let Datatype [con] [] = cdcont cc@@ -240,10 +243,10 @@  getEqs :: MB.TCM [(Bool, I.Term, I.Term)] getEqs = do- eqs <- getConstraints+ eqs <- getAllConstraints  let r = mapM (\eqc -> do           neqc <- norm eqc-          case MB.clValue neqc of+          case MB.clValue $ MB.theConstraint neqc of            MB.ValueCmp ineq _ i e -> do             ei <- etaContract i             ee <- etaContract e@@ -252,9 +255,7 @@             I.El _ ei <- etaContract i             I.El _ ee <- etaContract e             return [(tomyIneq ineq, ee, ei)]-           MB.Guarded (MB.UnBlock _) cs -> do-            eqs' <- r cs-            return $ concat eqs'+           MB.Guarded (MB.UnBlock _) pid -> return []            _ -> return []          )  eqs' <- r eqs@@ -285,7 +286,7 @@   def <- lift $ getConstInfo n   cc <- lift $ liftIO $ readIORef c   let Just npar = fst $ cdorigin cc-  return $ PatConApp c (replicate (fromIntegral npar) PatExp ++ pats')+  return $ PatConApp c (replicate npar PatExp ++ pats')  I.LitP _ -> throwError $ strMsg "Auto: Literals in patterns are not supported"  tomyBody (I.Body t) = do@@ -297,11 +298,7 @@  return $ case res of   Nothing -> Nothing   Just (b', i) -> Just (b', i + 1)-tomyBody (I.NoBind b) = do- res <- tomyBody b- return $ case res of-  Nothing -> Nothing-  Just (b', i) -> Just (weaken i b', i + 1)+tomyBody (I.Bind (I.NoAbs _ b)) = tomyBody b tomyBody I.NoBody = return Nothing  weaken :: Int -> MExp O -> MExp O@@ -350,14 +347,15 @@ tomyExp (I.Var v as) = do  as' <- tomyExps as  return $ NotM $ App Nothing (NotM OKVal) (Var $ fromIntegral v) as'-tomyExp (I.Lam hid (I.Abs name b)) = do- b' <- tomyExp b- return $ NotM $ Lam (cnvh hid) (Abs (Id name) b')+tomyExp (I.Lam hid b) = do+ b' <- tomyExp (I.absBody b)+ return $ NotM $ Lam (cnvh hid) (Abs (Id $ I.absName b) b') tomyExp t@(I.Lit{}) = do  t <- lift $ constructorForm t  case t of   I.Lit{} -> throwError $ strMsg "Auto: Literals in terms are not supported"   _ -> tomyExp t+tomyExp (I.Level l) = tomyExp =<< lift (reallyUnLevelView l) tomyExp (I.Def name as) = do  c <- getConst False name TMAll  as' <- tomyExps as@@ -369,16 +367,13 @@  cc <- lift $ liftIO $ readIORef c  let Just npar = fst $ cdorigin cc  return $ NotM $ App Nothing (NotM OKVal) (Const c) (foldl (\x _ -> NotM $ ALConPar x) as' [1..npar])-tomyExp (I.Pi (C.Arg hid _ x) (I.Abs name y)) = do+tomyExp (I.Pi (C.Arg hid _ x) b) = do+ let y    = I.absBody b+     name = I.absName b  x' <- tomyType x  y' <- tomyType y  return $ NotM $ Pi Nothing (cnvh hid) (Agda.TypeChecking.Free.freeIn 0 y) x' (Abs (Id name) y')-tomyExp (I.Fun (C.Arg hid _ x) y) = do- x' <- tomyType x- y' <- tomyType y- return $ NotM $ Pi Nothing (cnvh hid) False x' (Abs NoId (weaken 0 y'))-tomyExp (I.Sort (I.Type (I.Lit (I.LitLevel _ l)))) = return $ NotM $ Sort $ Set $ fromIntegral l-tomyExp (I.Sort (I.MetaS _ _)) = throwError $ strMsg "Auto: Searching for a type of arbitrary set level is not supported"+tomyExp (I.Sort (I.Type (I.Max [I.ClosedLevel l]))) = return $ NotM $ Sort $ Set $ fromIntegral l tomyExp (I.Sort _) = return $ NotM $ Sort UnknownSort tomyExp t@I.MetaV{} = do  t <- lift $ instantiate t@@ -392,7 +387,7 @@    m <- getMeta mid    return $ Meta m   _ -> tomyExp t-tomyExp (I.DontCare) = return $ NotM $ dontCare+tomyExp (I.DontCare _) = return $ NotM $ dontCare  tomyExps [] = return $ NotM ALNil tomyExps (C.Arg hid _ a : as) = do@@ -410,45 +405,57 @@  fmExp :: I.MetaId -> I.Term -> Bool fmExp m (I.Var _ as) = fmExps m as-fmExp m (I.Lam _ (I.Abs _ b)) = fmExp m b+fmExp m (I.Lam _ b) = fmExp m (I.unAbs b) fmExp m (I.Lit _) = False+fmExp m (I.Level (I.Max as)) = any (fmLevel m) as fmExp m (I.Def _ as) = fmExps m as fmExp m (I.Con _ as) = fmExps m as-fmExp m (I.Pi x (I.Abs _ y)) = fmType m (C.unArg x) || fmType m y-fmExp m (I.Fun x y) = fmType m (C.unArg x) || fmType m y+fmExp m (I.Pi x y)  = fmType m (C.unArg x) || fmType m (I.unAbs y) fmExp m (I.Sort _) = False fmExp m (I.MetaV mid _) = mid == m-fmExp m (I.DontCare) = False+fmExp m (I.DontCare _) = False  fmExps m [] = False fmExps m (a : as) = fmExp m (C.unArg a) || fmExps m as +fmLevel :: I.MetaId -> I.PlusLevel -> Bool+fmLevel m I.ClosedLevel{} = False+fmLevel m (I.Plus _ l) = case l of+  I.MetaLevel m' _   -> m == m'+  I.NeutralLevel v   -> fmExp m v+  I.BlockedLevel _ v -> fmExp m v+  I.UnreducedLevel v -> fmExp m v+ -- ---------------------------------------------  cnvh C.NotHidden = NotHidden+cnvh C.Instance = Instance cnvh C.Hidden = Hidden icnvh NotHidden = C.NotHidden+icnvh Instance = C.Instance icnvh Hidden = C.Hidden  -- ---------------------------------------------  frommy = frommyExp +frommyType :: MExp O -> ErrorT String IO I.Type frommyType e = do  e' <- frommyExp e  return $ I.El (I.mkType 0) e'  -- 0 is arbitrary, sort not read by Agda when reifying-frommyExp :: MExp O -> IO I.Term++frommyExp :: MExp O -> ErrorT String IO I.Term frommyExp (Meta m) = do- bind <- readIORef $ mbind m+ bind <- lift $ readIORef $ mbind m  case bind of-  Nothing -> __IMPOSSIBLE__+  Nothing -> throwError "meta not bound"   Just e -> frommyExp (NotM e) frommyExp (NotM e) =  case e of   App _ _ (Var v) as ->    frommyExps 0 as (I.Var (fromIntegral v) [])   App _ _ (Const c) as -> do-   cdef <- readIORef c+   cdef <- lift $ readIORef c    let (iscon, name) = cdorigin cdef        (ndrop, h) = case iscon of {Just n -> (n, I.Con); Nothing -> (0, I.Def)}    frommyExps ndrop as (h name [])@@ -463,18 +470,17 @@   Sort (Set l) ->    return $ I.Sort (I.mkType (fromIntegral l))   Sort Type -> __IMPOSSIBLE__-  Sort UnknownSort -> return I.DontCare-  -- Sort UnknownSort -> return $ I.Sort (I.mkType 0) -- hoping that it's thrown away+  Sort UnknownSort -> return $ I.Sort (I.mkType 0) -- hoping that it's thrown away    AbsurdLambda hid ->    return $ I.Lam (icnvh hid) (I.Abs abslamvarname (I.Var 0 []))  -frommyExps :: Nat -> MArgList O -> I.Term -> IO I.Term+frommyExps :: Nat -> MArgList O -> I.Term -> ErrorT String IO I.Term frommyExps ndrop (Meta m) trm = do- bind <- readIORef $ mbind m+ bind <- lift $ readIORef $ mbind m  case bind of-  Nothing -> __IMPOSSIBLE__+  Nothing -> throwError "meta not bound"   Just e -> frommyExps ndrop (NotM e) trm frommyExps ndrop (NotM as) trm =  case as of@@ -485,11 +491,11 @@    frommyExps ndrop xs (addend (C.Arg (icnvh hid) C.Relevant x') trm)    ALProj eas idx hid xs -> do-   idx <- expandbind idx-   let c = case idx of-            NotM c -> c-            Meta{} -> __IMPOSSIBLE__-   cdef <- readIORef c+   idx <- lift $ expandbind idx+   c <- case idx of+            NotM c -> return c+            Meta{} -> throwError "meta not bound"+   cdef <- lift $ readIORef c    let name = snd $ cdorigin cdef    trm2 <- frommyExps 0 eas (I.Def name [])    frommyExps 0 xs (addend (C.Arg (icnvh hid) C.Relevant trm) trm2)@@ -510,9 +516,10 @@ modifyAbstractExpr = f  where   f (A.App i e1 (C.Arg h r (C.Named n e2))) = A.App i (f e1) (C.Arg h r (C.Named n (f e2)))-  f (A.Lam i (A.DomainFree h n) _) | show n == abslamvarname = A.AbsurdLam i h+  f (A.Lam i (A.DomainFree h rel n) _) | show n == abslamvarname = A.AbsurdLam i h   f (A.Lam i b e) = A.Lam i b (f e)   f (A.Rec i xs) = A.Rec i (map (\(n, e) -> (n, f e)) xs)+  f (A.RecUpdate i e xs) = A.RecUpdate i (f e) (map (\(n, e) -> (n, f e)) xs)   f (A.ScopedExpr i e) = A.ScopedExpr i (f e)   f e = e @@ -539,7 +546,7 @@         (ns', ps') <- cnvps ns ps         cc <- liftIO $ readIORef c2         let Just npar = fst $ cdorigin cc-        return (ns', HI hid (CSPatConApp c2 (replicate (fromIntegral npar) (HI Hidden CSOmittedArg) ++ ps')))+        return (ns', HI hid (CSPatConApp c2 (replicate npar (HI Hidden CSOmittedArg) ++ ps')))        I.DotP t -> do         (t2, _) <- runStateT (tomyExp t) (S {sConsts = (cmap, []), sMetas = initMapS, sEqs = initMapS, sCurMeta = Nothing, sMainMeta = mainm})         return (ns, HI hid (CSPatExp t2))@@ -548,7 +555,7 @@  return (reverse names, pats)  -frommyClause :: (CSCtx O, [CSPat O], Maybe (MExp O)) -> IO I.Clause+frommyClause :: (CSCtx O, [CSPat O], Maybe (MExp O)) -> ErrorT String IO I.Clause frommyClause (ids, pats, mrhs) = do  let ctel [] = return I.EmptyTel      ctel (HI hid (mid, t) : ctx) = do@@ -570,7 +577,7 @@        --CSPatVar v -> return (length ids + nv - 1 - v : perm, nv)        CSPatVar v -> return ((length ids - 1 - v, nv) : perm, nv + 1)        CSPatConApp c ps -> do-        cdef <- readIORef c+        cdef <- lift $ readIORef c         let (Just ndrop, _) = cdorigin cdef         getperms ndrop ps perm nv        CSPatExp e -> return (perm, nv + 1)@@ -593,7 +600,7 @@       p' <- case p of        CSPatVar v -> return (I.VarP $ let HI _ (Id n, _) = ids !! v in n)        CSPatConApp c ps -> do-        cdef <- readIORef c+        cdef <- lift $ readIORef c         let (Just ndrop, name) = cdorigin cdef         ps' <- cnvps ndrop ps         return (I.ConP name Nothing ps')@@ -612,7 +619,7 @@                r n = I.Bind $ I.Abs "h" $ r (n - 1)                e'' = r ({-length ids + -}nv)            return e''- return $ I.Clause SP.noRange tel (Perm (fromIntegral $ nv{- + length ids-}) (map fromIntegral perm)) ps body+ return $ I.Clause SP.noRange tel (Perm (nv{- + length ids-}) perm) ps body  contains_constructor :: [CSPat O] -> Bool contains_constructor = any f@@ -625,8 +632,8 @@ etaContractBody :: I.ClauseBody -> MB.TCM I.ClauseBody etaContractBody (I.NoBody) = return I.NoBody etaContractBody (I.Body b) = etaContract b >>= \b -> return (I.Body b)-etaContractBody (I.NoBind b) = etaContractBody b >>= \b -> return (I.NoBind b) etaContractBody (I.Bind (I.Abs id b)) = etaContractBody b >>= \b -> return (I.Bind (I.Abs id b))+etaContractBody (I.Bind (I.NoAbs x b))  = I.Bind . I.NoAbs x <$> etaContractBody b   -- ---------------------------------@@ -672,18 +679,16 @@   let res = do         def <- Map.elems $ MB.sigDefinitions sig         MB.Function{MB.funClauses = cs} <- [MB.theDef def]-        c <- map I.translatedClause cs+        c <- cs         unless (peelbinds False findMeta $ I.clauseBody c) []         return (MB.defName def, c, peelbinds __IMPOSSIBLE__ toplevel $ I.clauseBody c)   return $ case res of     [] -> Nothing-    [r] -> Just r-    _ -> __IMPOSSIBLE__+    r:_ -> Just r   -- TODO: with pattern matching lambdas we might get more than one hit, which to choose?   where     peelbinds d f = r      where r b = case b of                   I.Bind b -> r $ I.absBody b-                  I.NoBind b -> r b                   I.NoBody -> d                   I.Body e -> f e     findMeta e =@@ -691,13 +696,13 @@       I.Var _ as -> findMetas as       I.Lam _ b -> findMeta (I.absBody b)       I.Lit{} -> False+      I.Level (I.Max as) -> any (fmLevel m) as       I.Def _ as -> findMetas as       I.Con _ as -> findMetas as-      I.Pi it ot -> findMetat (C.unArg it) || findMetat (I.absBody ot)-      I.Fun it ot -> findMetat (C.unArg it) || findMetat ot+      I.Pi it ot -> findMetat (C.unArg it) || findMetat (I.unAbs ot)       I.Sort{} -> False       I.MetaV m' _  -> m == m'-      I.DontCare -> False+      I.DontCare _ -> False     findMetas = any (findMeta . C.unArg)     findMetat (I.El _ e) = findMeta e     toplevel e =@@ -718,8 +723,8 @@    case ft 0 0 Just ctyp ttyp of     Just n -> Just (n, narg)     Nothing -> case ctyp of-     I.El _ (I.Pi _ ot) -> tr (narg + 1) (na + 1) (I.absBody ot)-     I.El _ (I.Fun _ ot) -> tr (narg + 1) na ot+     I.El _ (I.Pi _ (I.Abs _ ot)) -> tr (narg + 1) (na + 1) ot+     I.El _ (I.Pi _ (I.NoAbs _ ot)) -> tr (narg + 1) na ot      _ -> Nothing    where     ft nl n c (I.El _ e1) (I.El _ e2) = f nl n c e1 e2@@ -739,9 +744,6 @@       (I.Def n1 as1, I.Def n2 as2) | n1 == n2 -> fs nl (n + 1) c as1 as2       (I.Con n1 as1, I.Con n2 as2) | n1 == n2 -> fs nl (n + 1) c as1 as2       (I.Pi (C.Arg hid1 rel1 it1) ot1, I.Pi (C.Arg hid2 rel2 it2) ot2) | hid1 == hid2 -> ft nl n (\n -> ft (nl + 1) n c (I.absBody ot1) (I.absBody ot2)) it1 it2-      (I.Fun (C.Arg hid1 rel1 it1) ot1, I.Fun (C.Arg hid2 rel2 it2) ot2) | hid1 == hid2 -> ft nl n (\n -> ft nl n c ot1 ot2) it1 it2-      (I.Fun (C.Arg hid1 rel1 it1) ot1, I.Pi (C.Arg hid2 rel2 it2) ot2) | hid1 == hid2 -> ft nl n (\n -> ft (nl + 1) n c (raise 1 ot1) (I.absBody ot2)) it1 it2-      (I.Pi (C.Arg hid1 rel1 it1) ot1, I.Fun (C.Arg hid2 rel2 it2) ot2) | hid1 == hid2 -> ft nl n (\n -> ft (nl + 1) n c (I.absBody ot1) (raise 1 ot2)) it1 it2       (I.Sort{}, I.Sort{}) -> c n -- sloppy       _ -> Nothing     fs nl n c es1 es2 = case (es1, es2) of

src/full/Agda/Auto/Syntax.hs view

@@ -49,6 +49,7 @@   data FMode = Hidden+           | Instance            | NotHidden  deriving Eq

src/full/Agda/Compiler/Epic/AuxAST.hs view

@@ -1,3 +1,4 @@+{-# LANGUAGE CPP #-} -- | Intermediate abstract syntax tree used in the compiler. Pretty close to --   Epic syntax. module Agda.Compiler.Epic.AuxAST where@@ -7,9 +8,11 @@  import Agda.Syntax.Abstract.Name -type Var = String-type Tag = Int+import Agda.Compiler.Epic.Interface +#include "../../undefined.h"+import Agda.Utils.Impossible+ type Comment  = String type Inline   = Bool @@ -17,12 +20,14 @@   = Fun       { funInline  :: Inline       , funName    :: Var+      , funQName   :: Maybe QName       , funComment :: Comment       , funArgs    :: [Var]       , funExpr    :: Expr       }   | EpicFun       { funName     :: Var+      , funQName    :: Maybe QName       , funComment  :: Comment       , funEpicCode :: String --EpicCode       }@@ -35,6 +40,7 @@   | LFloat  Double   deriving (Show, Ord, Eq) + data Expr   = Var Var   | Lit Lit@@ -55,11 +61,58 @@   | Default {brExpr :: Expr}   deriving (Show, Ord, Eq) +getBrVars :: Branch -> [Var]+getBrVars (Branch {brVars = vs}) = vs+getBrVars _                      = []++--------------------------------------------------------------------------------+-- * Some smart constructors++-- | Smart constructor for let expressions to avoid unneceessary lets+lett :: Var -> Expr -> Expr -> Expr+lett v (Var v') e' = subst v v' e'+lett v e        e' = if v `elem` fv e' then Let v e e' else e'++-- | Some things are pointless to make lazy+lazy :: Expr -> Expr+lazy (Lazy e) = Lazy e+lazy (Lit l)  = Lit l+lazy UNIT     = UNIT+lazy x        = Lazy x++-- | If casing on the same expression in a sub-expression, we know what branch to+--   pick+casee :: Expr -> [Branch] -> Expr+casee x brs = Case x [br{brExpr = casingE br (brExpr br)} | br <- brs]+  where+    casingE br expr = let rec = casingE br in case expr of+      Var v -> Var v+      Lit l -> Lit l+      Lam v e -> Lam v (rec e)+      Con t n es -> Con t n (map rec es)+      App v es   -> App v (map rec es)+      Case e brs | expr == e -> case filter (sameCon br) brs of+        []  -> Case (rec e) [b {brExpr = rec (brExpr b)} | b <- brs]+        [b] -> substs (getBrVars br `zip` getBrVars b) (brExpr b)+        _   -> __IMPOSSIBLE__+                 | otherwise -> Case (rec e) [b {brExpr = rec (brExpr b)} | b <- brs]+      If e1 e2 e3 -> If (rec e1) (rec e2) (rec e3)+      Let v e1 e2 -> Let v (rec e1) (rec e2)+      Lazy e      -> Lazy (rec e)+      UNIT        -> UNIT+      IMPOSSIBLE  -> IMPOSSIBLE+    sameCon (Branch {brTag = t1}) (Branch {brTag = t2}) = t1 == t2+    sameCon (BrInt  {brInt = i1}) (BrInt  {brInt = i2}) = i1 == i2+    sameCon _                     _                     = False+ -- | Smart constructor for applications to avoid empty applications apps :: Var -> [Expr] -> Expr apps v [] = Var v apps v as = App v as +--------------------------------------------------------------------------------+-- * Substitution+ -- | Substitution subst :: Var  -- ^ Substitute this ...       -> Var  -- ^ with this ...@@ -83,6 +136,9 @@     UNIT       -> UNIT     IMPOSSIBLE -> IMPOSSIBLE +substs :: [(Var, Var)] -> Expr -> Expr+substs ss e = foldr (uncurry subst) e ss+ substBranch :: Var -> Var -> Branch -> Branch substBranch x e br = br { brExpr = subst x e (brExpr br) } @@ -109,9 +165,3 @@       Branch _ _ vs e -> fv' e S.\\ S.fromList vs       BrInt _ e       -> fv' e       Default e       -> fv' e---- | Filter a list using a list of Bools specifying what to keep.-pairwiseFilter :: [Bool] -> [a] -> [a]-pairwiseFilter (True :bs) (a:as) = a : pairwiseFilter bs as-pairwiseFilter (False:bs) (_:as) = pairwiseFilter bs as-pairwiseFilter _           _     = []

+ src/full/Agda/Compiler/Epic/CaseOpts.hs view

@@ -0,0 +1,42 @@+-- | Perform simple optimisations based on case-laws+module Agda.Compiler.Epic.CaseOpts where++import Control.Applicative+import Control.Monad++import Agda.TypeChecking.Monad++import Agda.Compiler.Epic.AuxAST+import Agda.Compiler.Epic.CompileState+import Agda.Compiler.Epic.Interface++caseOpts :: [Fun] -> Compile TCM [Fun]+caseOpts = mapM  $ \ def -> case def of+  Fun{} -> do+    e' <- caseOptsExpr (funExpr def)+    return def { funExpr = e' }+  _     -> return def++-- | Run the case-opts on an expression+caseOptsExpr :: Expr -> Compile TCM Expr+caseOptsExpr expr = case expr of+  Var v       -> return $ Var v+  Lit l       -> return $ Lit l+  Lam v e     -> Lam v <$> caseOptsExpr e+  Con c n es  -> Con c n <$> mapM caseOptsExpr es+  App v es    -> apps v <$> mapM caseOptsExpr es+  -- If there is only one constructor branch, perform a projection to get the result+  Case e [Branch {brVars = vs, brExpr = eorg}] -> do+      e' <- caseOptsExpr eorg+      bindExpr e $ \var ->+        return $ foldr (\(v, n) -> lett v $ App "proj" [Lit (LInt n), Var var]) e'+               $ zip vs [0..]+  -- If there is only a default branch, the case is not necessary+  Case e [Default{brExpr = e'}] -> caseOptsExpr e'+  Case e brs  -> Case <$> caseOptsExpr e <*> (mapM (\br -> do e' <- caseOptsExpr (brExpr br)+                                                              return br {brExpr = e'}) brs)+  If a b c    -> If <$> caseOptsExpr a <*> caseOptsExpr b <*> caseOptsExpr c+  Let v e1 e2 -> Let v <$> caseOptsExpr e1 <*> caseOptsExpr e2+  Lazy e      -> Lazy <$> caseOptsExpr e+  UNIT        -> return UNIT+  IMPOSSIBLE  -> return IMPOSSIBLE

src/full/Agda/Compiler/Epic/CompileState.hs view

@@ -6,57 +6,69 @@  import Control.Applicative import Control.Monad.State+import Data.List import Data.Map(Map) import qualified Data.Map as M import Data.Maybe+import Data.Monoid import Data.Set(Set) import qualified Data.Set as S -import Agda.Compiler.Epic.AuxAST+import Agda.Compiler.Epic.AuxAST as AuxAST+import Agda.Compiler.Epic.Interface+import Agda.Interaction.Options import Agda.Syntax.Internal+import Agda.Syntax.Concrete(TopLevelModuleName) import Agda.Syntax.Common-import Agda.TypeChecking.Monad (MonadTCM, internalError, defType, theDef, getConstInfo)-import qualified Agda.TypeChecking.Monad as M+import Agda.TypeChecking.Monad (TCM, internalError, defType, theDef, getConstInfo, sigDefinitions, stImports, stPersistentOptions, stPersistent)+import qualified Agda.TypeChecking.Monad as TM import Agda.TypeChecking.Reduce  #include "../../undefined.h" import Agda.Utils.Impossible+import Agda.Utils.Monad -type IrrFilter = [Bool]  -- | Stuff we need in our compiler data CompileState = CompileState-    { dataDecls     :: Map QName Tag-    , nameSupply    :: [Var]-    , definitions   :: Set Var-    , defDelayed    :: Map QName Bool-    , conPars       :: Map QName Int-    , mainName      :: Maybe QName-    , irrFilters    :: Map QName IrrFilter+    { nameSupply      :: [Var]+    , compiledModules :: Map TopLevelModuleName (EInterface, Set FilePath)+    , curModule       :: EInterface+    , importedModules :: EInterface+    , curFun          :: String     } deriving Show  -- | The initial (empty) state initCompileState :: CompileState initCompileState = CompileState-    { dataDecls     = M.empty-    , nameSupply    = map (('h':) . show) [0 :: Integer ..]-    , definitions   = S.fromList primTopBindings-    , defDelayed    = M.empty-    , conPars       = M.empty-    , mainName      = Nothing-    , irrFilters    = M.empty+    { nameSupply        = map (('h':) . show) [0 :: Integer ..]+    , compiledModules   = M.empty+    , curModule         = mempty+    , importedModules   = mempty+    , curFun            = undefined     }-  where-    -- | For the lambda-lifter not to lift known primitive functions.-    primTopBindings :: [Var]-    primTopBindings = ["primNatCaseZD", "primNatCaseZS", "primBoolCase", "primUnit", "primSharp"]  -- | Compiler monad type Compile = StateT CompileState -epicError :: MonadTCM m => String -> Compile m a+-- | When normal errors are not enough+epicError :: String -> Compile TCM a epicError = lift . internalError +-- | Modify the state of the current module's Epic Interface+modifyEI :: (EInterface -> EInterface) -> Compile TCM ()+modifyEI f = modify $ \s -> s {curModule = f (curModule s)}++-- | Get the state of the current module's Epic Interface+getsEI :: (EInterface -> a) -> Compile TCM a+getsEI f = gets (f . curModule)++-- | Returns the type of a definition given its name+getType :: QName -> Compile TCM Type+getType q = do+    map <- lift (gets (sigDefinitions . stImports))+    return $ maybe __IMPOSSIBLE__ defType (M.lookup q map)+ -- | Create a name which can be used in Epic code from a QName. unqname :: QName -> Var unqname qn = case nameId $ qnameName qn of@@ -65,70 +77,138 @@  -- * State modifiers -getDelayed :: MonadTCM m => QName -> Compile m Bool-getDelayed q = fromMaybe False <$> gets (M.lookup q . defDelayed)+resetNameSupply :: Compile TCM ()+resetNameSupply = modify $ \s -> s {nameSupply = nameSupply initCompileState} -putDelayed :: Monad m => QName -> Bool -> Compile m ()-putDelayed q d = modify $ \s -> s {defDelayed = M.insert q d (defDelayed s)}+getDelayed :: QName -> Compile TCM Bool+getDelayed q = lookInterface (M.lookup q . defDelayed) (return False) -newName :: Monad m => Compile m Var+putDelayed :: QName -> Bool -> Compile TCM ()+putDelayed q d = modifyEI $ \s -> s {defDelayed = M.insert q d (defDelayed s)}++newName :: Compile TCM Var newName = do     n:ns <- gets nameSupply     modify $ \s -> s { nameSupply = ns}     return n --- | Add a data declaration by giving a list of its constructors.---   Tags will be created and saved.-addDataDecl :: Monad m => [QName] -> Compile m ()-addDataDecl ts = modify-    $ \s -> s { dataDecls = M.union (M.fromList $ zip ts [0..]) (dataDecls s)}+putConstrTag :: QName -> Tag -> Compile TCM ()+putConstrTag q t = modifyEI $ \s -> s { constrTags = M.insert q t $ constrTags s } -getConstrTag :: Monad m => QName -> Compile m Tag-getConstrTag con = gets $ fromMaybe __IMPOSSIBLE__-                        . M.lookup con-                        . dataDecls+assignConstrTag :: QName -> Compile TCM Tag+assignConstrTag constr = assignConstrTag' constr [] -addDefName :: Monad m => QName -> Compile m ()+assignConstrTag' :: QName -> [QName] -> Compile TCM Tag+assignConstrTag' constr constrs = do+    constrs <- concat <$> mapM ((getDataCon =<<) . getConData) (constr : constrs)+    tags    <- catMaybes <$> mapM getConstrTag' constrs+    let tag =  head $ map Tag [0..] \\ tags+    putConstrTag constr tag+    return tag++getConData :: QName -> Compile TCM QName+getConData con = do+    lmap <- lift (gets (TM.sigDefinitions . TM.stImports))+    case M.lookup con lmap of+        Just def -> case theDef def of+            c@(TM.Constructor{}) -> return $ TM.conData c+            _                 -> __IMPOSSIBLE__+        Nothing -> __IMPOSSIBLE__++getDataCon :: QName -> Compile TCM [QName]+getDataCon con = do+    lmap <- lift (gets (TM.sigDefinitions . TM.stImports))+    case M.lookup con lmap of+        Just def -> case theDef def of+            d@(TM.Datatype{}) -> return $ TM.dataCons d+            r@(TM.Record{})   -> return [ TM.recCon r]+            _                 -> __IMPOSSIBLE__+        Nothing -> __IMPOSSIBLE__++getConstrTag :: QName -> Compile TCM Tag+getConstrTag con = lookInterface (M.lookup con . constrTags)+                                 (assignConstrTag con)++getConstrTag' :: QName -> Compile TCM (Maybe Tag)+getConstrTag' con = do+    cur <- gets curModule+    case M.lookup con (constrTags cur) of+        Just x -> return (Just x)+        Nothing -> do+            imps <- gets importedModules+            return $ M.lookup con (constrTags imps)++addDefName :: QName -> Compile TCM () addDefName q = do-    modify $ \s -> s {definitions = S.insert (unqname q) $ definitions s }-    when ("main" == show (qnameName q)) (putMain q) -- hax+    modifyEI $ \s -> s {definitions = S.insert (unqname q) $ definitions s } -topBindings :: Monad m => Compile m (Set Var)-topBindings = gets definitions+topBindings :: Compile TCM (Set Var)+topBindings = S.union <$> gets (definitions . importedModules) <*> gets (definitions . curModule) -getConPar :: MonadTCM m => QName -> Compile m Int-getConPar n = fromMaybe __IMPOSSIBLE__ <$> M.lookup n <$> gets conPars+getConArity :: QName -> Compile TCM Int+getConArity n = lookInterface (M.lookup n . conArity) __IMPOSSIBLE__ -putConPar :: Monad m => QName -> Int -> Compile m ()-putConPar n p = modify $ \s -> s { conPars = M.insert n p (conPars s) }+putConArity :: QName -> Int -> Compile TCM ()+putConArity n p = modifyEI $ \s -> s { conArity = M.insert n p (conArity s) } -putMain :: Monad m => QName -> Compile m ()-putMain m = modify $ \s -> s { mainName = Just m }+putMain :: QName -> Compile TCM ()+putMain m = modifyEI $ \s -> s { mainName = Just m } -getMain :: MonadTCM m => Compile m Var-getMain = maybe (epicError "Where is main? :(") (return . unqname) =<< gets mainName+getMain :: Compile TCM Var+getMain = maybe (epicError "Where is main? :(") (return . unqname) =<< getsEI mainName -getIrrFilter :: Monad m => QName -> Compile m IrrFilter-getIrrFilter q = gets $ fromMaybe __IMPOSSIBLE__-                      . M.lookup q-                      . irrFilters+lookInterface :: (EInterface -> Maybe a) -> Compile TCM a -> Compile TCM a+lookInterface f def = do+    cur <- gets curModule+    case f cur of+        Just x -> return x+        Nothing -> do+            imps <- gets importedModules+            case f imps of+                Nothing -> def+                Just x  -> return x -putIrrFilter :: Monad m => QName -> IrrFilter -> Compile m ()-putIrrFilter n f = modify $ \s -> s {irrFilters = M.insert n f $ irrFilters s}+constrInScope :: QName -> Compile TCM Bool+constrInScope name = do+    cur <- gets curModule+    case M.lookup name (constrTags cur) of+        Just x -> return True+        Nothing -> do+            imps <- gets importedModules+            case M.lookup name (constrTags imps) of+                Nothing -> return False+                Just x  -> return True +getForcedArgs :: QName -> Compile TCM ForcedArgs+getForcedArgs q = lookInterface (M.lookup q . forcedArgs) __IMPOSSIBLE__++putForcedArgs :: QName -> ForcedArgs -> Compile TCM ()+putForcedArgs n f = do+  b <- lift $ gets (optForcing . stPersistentOptions . stPersistent)+  let f' | b = f+         | otherwise = replicate (length f) NotForced+  modifyEI $ \s -> s {forcedArgs = M.insert n f' $ forcedArgs s}+ replaceAt :: Int -- ^ replace at           -> [a] -- ^ to replace           -> [a] -- ^ replace with           -> [a] -- ^ result? replaceAt n xs inserts = let (as, _:bs) = splitAt n xs in as ++ inserts ++ bs - -- | Copy pasted from MAlonzo, HAHA!!! --   Move somewhere else!-constructorArity :: (MonadTCM tcm, Num a) => QName -> tcm a+constructorArity :: Num a => QName -> TCM a constructorArity q = do   def <- getConstInfo q   a <- normalise $ defType def   case theDef def of-    M.Constructor{ M.conPars = np } -> return . fromIntegral $ arity a - np+    TM.Constructor{ TM.conPars = np } -> return . fromIntegral $ arity a - np     _ -> internalError $ "constructorArity: non constructor: " ++ show q++-- | Bind an expression to a fresh variable name+bindExpr :: Expr -> (Var -> Compile TCM Expr) -> Compile TCM Expr+bindExpr expr f = case expr of+  AuxAST.Var v -> f v+  _     -> do+      v <- newName+      lett v expr <$> f v

src/full/Agda/Compiler/Epic/Compiler.hs view

@@ -6,100 +6,189 @@ import Control.Monad import Control.Monad.Reader import Control.Monad.State+import qualified Data.ByteString.Lazy as BS import qualified Data.Map as M+import Data.Set(Set)+import qualified Data.Set as S import Data.Maybe+import Data.Monoid+import qualified Language.Haskell.Exts.Syntax as Haskell import System.Directory import System.Exit import System.FilePath hiding (normalise) import System.Process hiding (env)  import Paths_Agda+import Agda.Compiler.MAlonzo.Pretty -- TODO: Move shared code to Compiler.*+import Agda.Compiler.MAlonzo.Primitives (checkTypeOfMain) import Agda.Interaction.FindFile import Agda.Interaction.Options+import Agda.Interaction.Imports import qualified Agda.Syntax.Concrete.Name as CN import Agda.Syntax.Internal hiding (Term(..)) import Agda.TypeChecking.Monad import Agda.TypeChecking.Monad.Builtin+import Agda.TypeChecking.Serialise import Agda.Utils.FileName -import Agda.Compiler.Epic.CompileState hiding (conPars)-import qualified Agda.Compiler.Epic.ConstructorIrrelevancy as CIrr+import qualified Agda.TypeChecking.Pretty as P++import Agda.Compiler.Epic.CompileState+import qualified Agda.Compiler.Epic.CaseOpts     as COpts+import qualified Agda.Compiler.Epic.ForceConstrs as ForceC import Agda.Compiler.Epic.Epic-import qualified Agda.Compiler.Epic.Erasure as Eras-import qualified Agda.Compiler.Epic.FromAgda as FAgda-import qualified Agda.Compiler.Epic.LambdaLift as LL-import qualified Agda.Compiler.Epic.Primitive  as Prim+import Agda.Compiler.Epic.Interface+import qualified Agda.Compiler.Epic.Erasure      as Eras+import qualified Agda.Compiler.Epic.FromAgda     as FAgda+import qualified Agda.Compiler.Epic.Forcing      as Forcing+import qualified Agda.Compiler.Epic.Injection    as ID+import qualified Agda.Compiler.Epic.NatDetection as ND+import qualified Agda.Compiler.Epic.Primitive    as Prim+import qualified Agda.Compiler.Epic.Smashing     as Smash  #include "../../undefined.h" import Agda.Utils.Impossible --- | Compile an interface into an Epic/a.out program---   /actually this is not true, we compile everything so we don't even look at---   the Interface. This may change in the future.+compilePrelude :: Compile TCM ()+compilePrelude = do+    dataDir <- (</> "EpicInclude") <$> liftIO getDataDir+    pwd <- liftIO $ getCurrentDirectory+    liftIO $ setCurrentDirectory dataDir+    let prelude = "AgdaPrelude"+    uptodate <- liftIO $ (prelude <.> "ei") `isNewerThan` (prelude <.> "e")+    when (not uptodate) $ callEpic False [ "-c" , prelude <.> "e" ]+    liftIO $ setCurrentDirectory pwd++-- | Compile an interface into an executable using Epic compilerMain :: Interface -> TCM () compilerMain inter = do     epic_exist <- liftIO $ rawSystem "ghc-pkg" ["-v0", "field", "epic", "id"]     case epic_exist of         ExitSuccess -> flip evalStateT initCompileState $ do+            compilePrelude             setEpicDir inter-            initialAnalysis-            code <- compileModule =<< lift (gets stImports)-            case code of-                Nothing -> __IMPOSSIBLE__-                Just c  -> runEpic (iModuleName inter) c+            (_, imports) <- compileModule inter+            main <- getMain+            runEpicMain main (S.toList imports) (iModuleName inter)+         ExitFailure _ -> internalError $ unlines            [ "Agda cannot find the Epic compiler."            , "This can perhaps be fixed by running `cabal install epic'."            , "See the README for more information."            ] +outFile :: CN.TopLevelModuleName -> Compile TCM FilePath+outFile mod = do+  let (dir, fn) = splitFileName . foldl1 (</>) $ CN.moduleNameParts mod+      fp  | dir == "./"  = "src" </> fn+          | otherwise = "src" </> dir </> fn+  liftIO $ createDirectoryIfMissing True ("src" </> dir)+  return $ fp+  where+  repldot c = map (\c' -> if c' == '.' then c else c') +readEInterface :: FilePath -> Compile TCM EInterface+readEInterface file = fromMaybe __IMPOSSIBLE__+                   <$> lift (decode =<< liftTCM (liftIO (BS.readFile file)))++compileModule :: Interface -> Compile TCM (EInterface, Set FilePath)+compileModule i = do+    cm <- gets compiledModules+    let moduleName = toTopLevelModuleName $ iModuleName i+    file  <- outFile moduleName+    case M.lookup moduleName cm of+        Just eifs -> return eifs+        Nothing  -> do+            imports <- map miInterface . catMaybes+                                      <$> mapM (lift . getVisitedModule . toTopLevelModuleName)+                                               (iImportedModules i)+            (ifaces, limps) <- mapAndUnzipM compileModule imports+            let imps = S.unions limps+            modify $ \s -> s { importedModules = importedModules s `mappend` mconcat ifaces }+            ifile <- maybe __IMPOSSIBLE__ filePath <$> lift (findInterfaceFile moduleName)+            let eifFile = file <.> "aei"+            uptodate <- liftIO $ isNewerThan eifFile ifile+            (eif, imps') <- case uptodate of+                True  -> do+                    lift $ reportSLn "" 1 $+                        show (iModuleName i) ++ " : no compilation is needed."+                    eif <- readEInterface eifFile+                    modify $ \s -> s { curModule = eif }+                    return (eif, S.insert file imps)+                False -> do+                    lift $ reportSLn "" 1 $+                        "Compiling: " ++ show (iModuleName i)+                    resetNameSupply+                    initialAnalysis i+                    let defns = M.toList $ sigDefinitions $ iSignature i+                    -- Epic cannot parse files with no definitions+                    if (not $ null defns) then do+                        code <- compileDefns defns+                        runEpic file (S.toList imps) code+                        eif <- gets curModule+                        lift $ do+                            bif <- encode eif+                            liftIO $ BS.writeFile eifFile bif+                        return (eif, S.insert file imps)+                     else+                        flip (,) imps <$> gets curModule+            modify $ \s -> s { compiledModules = (M.insert moduleName (eif, imps') (compiledModules s))}+            return (eif, imps')+ -- | Before running the compiler, we need to store some things in the state, --   namely constructor tags, constructor irrelevancies and the delayed field --   in functions (for coinduction).-initialAnalysis :: MonadTCM m => Compile m ()-initialAnalysis = do-  defs <- M.toList <$> lift (gets (sigDefinitions . stImports))+initialAnalysis :: Interface -> Compile TCM ()+initialAnalysis inter = do+  Prim.initialPrims+  modify $ \s -> s {curModule = mempty}+  let defs = M.toList $ sigDefinitions $ iSignature inter   forM_ defs $ \(q, def) -> do     addDefName q     case theDef def of       d@(Datatype {}) -> do-        addDataDecl $ dataCons d+        saker <- ND.isNatish q d+        case saker of+            Just (_, [zer, suc]) -> do+                putConstrTag zer (PrimTag "primZero")+                putConstrTag suc (PrimTag "primSuc")+            _ -> return ()       Constructor {conPars = np} -> do-        putIrrFilter q . drop (fromIntegral np) . CIrr.irrFilter $ defType def-        putConPar q =<< lift (constructorArity q)-      r@(Record{}) -> do-        addDataDecl [recCon r]+        putForcedArgs q . drop (fromIntegral np) . ForceC.makeForcedArgs $ defType def+        putConArity q =<< lift (constructorArity q)       f@(Function{}) -> do+        when ("main" == show (qnameName q)) $ do+            -- lift $ liftTCM $ checkTypeOfMain q (defType def)+            putMain q         putDelayed q $ case funDelayed f of           Delayed -> True           NotDelayed -> False+      a@(Axiom {}) -> do+        case defEpicDef def of+          Nothing -> putDelayed q True+          _       -> return ()       _ -> return () +idPrint s m x = do+  -- liftIO $ putStrLn s+  m x+ -- | Perform the chain of compilation stages, from definitions to epic code-compileDefns :: MonadTCM m => [(QName, Definition)] -> Compile m (Maybe EpicCode)+compileDefns :: [(QName, Definition)] -> Compile TCM EpicCode compileDefns defs = do     -- We need to handle sharp (coinduction) differently, so we get it here.     msharp <- lift $ getBuiltin' builtinSharp-    emits   <- FAgda.fromAgda msharp defs-               >>= Prim.primitivise-               >>= irr -- CIrr.constrIrr-               >>= Eras.erasure-               >>= LL.lambdaLift-    if null emits-       then return Nothing-       else return . return . unlines . map prettyEpicFun $ emits-  where-    irr ds = do-        f <- lift $ gets (optForcing . stPersistentOptions)-        if f then CIrr.constrIrr ds-             else return ds---- | Compile all definitions from a signature-compileModule :: MonadTCM m => Signature -> Compile m (Maybe EpicCode)-compileModule sig = do-    let defs = M.toList $ sigDefinitions sig-    compileDefns defs+    emits   <- return defs+               >>= idPrint "findInjection" ID.findInjection+               >>= idPrint "fromAgda"   (FAgda.fromAgda msharp)+               >>= idPrint "forcing"     Forcing.remForced+               >>= idPrint "irr"         ForceC.forceConstrs+               >>= idPrint "primitivise" Prim.primitivise+               >>= idPrint "smash"       Smash.smash'em+               >>= idPrint "erasure"     Eras.erasure+               >>= idPrint "caseOpts"    COpts.caseOpts+               >>= idPrint "done" return+    unlines <$> mapM prettyEpicFun emits  -- | Change the current directory to Epic folder, create it if it doesn't already --   exist.@@ -107,7 +196,8 @@ setEpicDir mainI = do     let tm = toTopLevelModuleName $ iModuleName mainI     f <- lift $ findFile tm-    compileDir' <- lift $ gets (fromMaybe (filePath $ CN.projectRoot f tm) . optCompileDir . stPersistentOptions)+    compileDir' <- lift $ gets (fromMaybe (filePath $ CN.projectRoot f tm) .+                                  optCompileDir . stPersistentOptions . stPersistent)     compileDir <- liftIO $ canonicalizePath compileDir'     liftIO $ setCurrentDirectory compileDir     liftIO $ createDirectoryIfMissing False "Epic"@@ -117,30 +207,59 @@ -- -- The program is written to the file @../m@, where m is the last -- component of the given module name.-runEpic :: MonadTCM m => ModuleName -> EpicCode -> Compile m ()-runEpic m code = do-    nam <- getMain-    epicflags <- optEpicFlags <$> lift commandLineOptions-    let code' = "include \"AgdaPrelude.e\"\n" ++ code ++ "main() -> Unit = init() ; " ++ nam ++ "(unit)"-    dataDir <- liftIO getDataDir-    curDir  <- liftIO getCurrentDirectory-    liftIO $ copyFile (dataDir </> "EpicInclude" </> "AgdaPrelude" <.> "e")-                      (curDir </> "AgdaPrelude" <.> "e")-    liftIO $ writeFile ("main" <.> "e") code'+runEpic :: FilePath -> [FilePath] -> EpicCode -> Compile TCM ()+runEpic fp imports code = do+    dataDir <- (</> "EpicInclude") <$> liftIO getDataDir+    let imports' = unlines ["include \"" ++ imp ++ "\""+                           | imp <- (dataDir </> "AgdaPrelude.ei")+                                    : map (<.> "ei") imports]+        code'    = imports' ++ code+    liftIO $ writeFile (fp <.> "e") code'+    callEpic True $+        [ "-c", fp <.> "e" ] +-- | Create the Epic main file, which calls the Agda main function+runEpicMain :: Var -> [FilePath] -> ModuleName -> Compile TCM ()+runEpicMain mainName imports m = do+    dataDir <- (</> "EpicInclude") <$> liftIO getDataDir+    let imports' = (dataDir </> "AgdaPrelude") : imports+    let code = unlines ["include \"" ++ imp <.> "ei" ++ "\""+                       | imp <- imports'+                       ] ++ "main() -> Unit = init() ; " ++ mainName ++ "(unit)"+    liftIO $ writeFile ("main" <.> "e") code     let outputName  = case mnameToList m of           [] -> __IMPOSSIBLE__           ms -> last ms-        epic        = "epic"+    callEpic'  $ \epic ->+        [ "main" <.> "e"+        , "-o", ".." </> show outputName+        ]+        ++ epic ++ map (<.> "o") imports'++-- | Call epic, with a given set of flags, if the |Bool| is True then include+-- the command line flags at the end+callEpic :: Bool -> [String] -> Compile TCM ()+callEpic incEFlags flags = callEpic' $ \epicFlags ->+  flags ++ if incEFlags then epicFlags else []++-- | Call epic with a given set of flags, the argument function receives the flags given+-- at the command line+callEpic' :: ([String] -> [String]) -> Compile TCM ()+callEpic' flags = do+    epicFlags <- optEpicFlags <$> lift commandLineOptions+    dataDir   <- (</> "EpicInclude") <$> liftIO getDataDir+    let epic        = "epic"         epicCommand =           [ "-keepc"-          , "-checking", "0"+          -- , "-g"+          -- , "-checking", "0"           -- , "-trace"-          , "-i", dataDir </> "EpicInclude" </> "stdagda" <.> "c"-          , "main" <.> "e"-          , "-o", ".." </> show outputName-          ] ++ epicflags+          , "-i", dataDir </> "stdagda" <.> "c"+          ] ++ flags epicFlags     lift $ reportSLn "" 1 $       "calling: " ++ unwords (epic : epicCommand)-    _ <- liftIO $ rawSystem epic epicCommand-    return ()+    res <- liftIO $ system (unwords (epic : epicCommand))+                  -- rawSystem epic epicCommand+    case res of+        ExitSuccess   -> return ()+        ExitFailure i -> epicError $ "Epic returned " ++ show res ++ ", which should not happen. Please report this as a bug."

− src/full/Agda/Compiler/Epic/ConstructorIrrelevancy.hs

@@ -1,67 +0,0 @@--- | Remove forced (irrelevant) arguments from constructors.-module Agda.Compiler.Epic.ConstructorIrrelevancy where--import Control.Applicative--import Agda.Compiler.Epic.AuxAST-import Agda.Compiler.Epic.CompileState--import Agda.Syntax.Common-import qualified Agda.Syntax.Internal as T-import Agda.TypeChecking.Monad.Base (MonadTCM)----- | Check which arguments are forced and create an IrrFilter-irrFilter :: T.Type -> IrrFilter-irrFilter (T.El _ term) = case term of-    T.Pi  arg ab  -> isRel arg : irrFilter (T.absBody ab)-    T.Fun arg typ -> isRel arg : irrFilter typ-    _ -> []-  where-    isRel :: Arg T.Type -> Bool-    isRel arg = case argRelevance arg of-      Relevant   -> True-      Irrelevant -> False-      Forced     -> False -- It can be inferred---- | Remove irrelevant arguments from constructors and branches-constrIrr :: MonadTCM m => [Fun] -> Compile m [Fun]-constrIrr fs = mapM irrFun fs--irrFun :: MonadTCM m => Fun -> Compile m Fun-irrFun (Fun inline name comment args expr) =-    Fun inline name comment args <$> irrExpr expr-irrFun e@(EpicFun{}) = return e---- | Remove all arguments to constructors that we don't need to store in an---   expression.-irrExpr :: MonadTCM m => Expr -> Compile m Expr-irrExpr expr = case expr of-    Var v        -> return $ Var v-    Lit l        -> return $ Lit l-    Lam v e      -> Lam v <$> irrExpr e-    Con tag q es -> do-        -- We only need to apply the relevant arguments-        irrFilt <- getIrrFilter q-        return $ Con tag q $ pairwiseFilter irrFilt es-    App v es     -> App v <$> mapM irrExpr es-    Case e bs    -> Case <$> irrExpr e <*> mapM irrBranch bs-    Let v e e'   -> Let v <$> irrExpr e <*> irrExpr e'-    If a b c     -> If <$> irrExpr a <*> irrExpr b <*> irrExpr c-    Lazy e       -> Lazy <$> irrExpr e-    UNIT         -> return expr-    IMPOSSIBLE   -> return expr---- | Remove all the arguments that doesn't need to be stored in the constructor---   For the branch-irrBranch :: MonadTCM m => Branch -> Compile m Branch-irrBranch br = case br of-    Branch  tag name vars e -> do-        ir <- getIrrFilter name-        let vs = pairwiseFilter ir vars-            -- The removed arguments are substituted for unit-            subs = pairwiseFilter (map not ir) vars-            e'   = foldr (\x ex -> subst x "primUnit" ex) e subs-        Branch tag name vs <$> irrExpr e'-    BrInt i e -> BrInt i <$> irrExpr e-    Default e -> Default <$> irrExpr e

src/full/Agda/Compiler/Epic/Epic.hs view

@@ -3,15 +3,28 @@ -- | Pretty-print the AuxAST to valid Epic code. module Agda.Compiler.Epic.Epic   ( prettyEpicFun+  , prettyEpic   ) where +import Control.Monad.State+ import Data.Char import Data.List +import Data.Map (Map)+import qualified Data.Map as M++import Agda.TypeChecking.Monad+import Agda.TypeChecking.Pretty (prettyTCM)+import Agda.TypeChecking.Reduce+ #include "../../undefined.h" import Agda.Utils.Impossible + import Agda.Compiler.Epic.AuxAST+import Agda.Compiler.Epic.CompileState+import Agda.Compiler.Epic.Interface  -- * Some auxilliary pretty-printer functions (<+>) :: String -> String -> String@@ -25,6 +38,10 @@ many :: [String] -> String many vs = paren $ intercalate ", " vs +many' :: [String] -> String+many' [] = ""+many' vs = paren $ intercalate ", " vs+ paren :: String -> String paren s = "(" <+> s <+> ")" @@ -33,46 +50,60 @@  -- * Pretty-printer -- | Print a function to an Epic string-prettyEpicFun :: Fun -> String-prettyEpicFun (Fun inline name comment vars e) =-    "--" <+> comment $$-    (if inline then "%inline " else "") ++ name-    <+> many (map typVar vars) <+> "-> Any" <+> "=" <+> prettyEpic e-prettyEpicFun (EpicFun name comment def) =+prettyEpicFun :: MonadTCM m => Fun -> Compile m String+prettyEpicFun (Fun inline name mqname comment vars e) = do+    {-+    defs <- lift (gets (sigDefinitions . stImports))+    typ <- case mqname >>= flip M.lookup defs of+      Nothing -> return "-"+      Just def -> do+        doc <- lift $ prettyTCM =<< normalise (defType def)+        return $ show doc+    -}+    return $+      "--" <+> comment $$+      -- unlines (map ("-- " <+>) (lines typ)) $$+      (if inline then "%inline " else "") ++ name+        <+> many (map typVar vars) <+> "-> Any" <+> "=" <+> prettyEpic e++prettyEpicFun (EpicFun name _mqname comment def) = return $     "--" <+> comment $$-    "%inline" <+> name <+> def+    {-"%inline" <+> -} name <+> def  -- | Print expression to Epic expression prettyEpic :: Expr -> String prettyEpic expr = case expr of     Var v -> v     Lit l -> prettyEpicLit l-    Lam _ _ -> __IMPOSSIBLE__ -- We have lambda lifted away all λs-    Con t q args -> curly (show q) <+> paren ("Con" <+> show t <+> many (map prettyEpic args))+    Lam x e -> paren $ "\\" <+> typVar x <+> "." <+> paren (prettyEpic e)-- __IMPOSSIBLE__ -- We have lambda lifted away all λs+    Con (Tag t) q args -> curly (show q) <+> paren ("Con" <+> show t <+> many (map prettyEpic args))     If a b c -> "if" <+> prettyEpic a <+> "then" <+> prettyEpic b <+> "else" <+> prettyEpic c-    Let v e e' -> "let" <+> typVar v <+> "=" <+> prettyEpic e <+> "in" <+> prettyEpic e'-    App v es -> v <+> many (map prettyEpic es)+    Let v e e' -> "let" <+> typVar v <+> "=" <+> prettyEpic (id e) <+> "in" <+> prettyEpic e'+    App "proj" (Lit (LInt n) : e : es) -> paren (prettyEpic e <+> "!" <+> show n) <+> many' (map prettyEpic es)+    App v es -> v <+> many' (map (prettyEpic . id) es)     Case e brs -> "case" <+> prettyEpic e <+> "of {"                <+> intercalate "\n | " (map prettyEpicBr brs) <+> "}"     Lazy e -> "lazy" <+> paren (prettyEpic e)     UNIT -> "unit"     IMPOSSIBLE -> "impossible"+    _ -> __IMPOSSIBLE__  prettyEpicBr :: Branch -> String prettyEpicBr br = case br of-    Branch c q vs e ->+    Branch (Tag c) q vs e ->        curly (show q)  <+>        "Con" <+> show c        <+> many (map typVar vs)        <+> "->" <+> prettyEpic e     BrInt n e       ->  show n <+> "->" <+> prettyEpic e     Default e       -> "Default ->" <+> prettyEpic e+    _ -> __IMPOSSIBLE__  prettyEpicLit :: Lit -> String prettyEpicLit l = case l of     LInt n    -> show n ++ "L"     LChar c   -> show (ord c)-    LString s -> show s+    LString s -> "Con 1" <+> many [show s, "Con 0 ()"]     LFloat f  -> show f  typVar :: Var -> String

src/full/Agda/Compiler/Epic/Erasure.hs view

@@ -1,3 +1,4 @@+{-# LANGUAGE CPP #-} -- | Some arguments to functions (types in particular) will not be used in the --   body. Wouldn't it be useful if these wasn't passed around at all? --   Fear not, we here perform some analysis and try to remove as many of these@@ -18,65 +19,76 @@  import Agda.Compiler.Epic.AuxAST import Agda.Compiler.Epic.CompileState+import Agda.Compiler.Epic.Interface -import Agda.TypeChecking.Monad.Base (MonadTCM)+import Agda.TypeChecking.Monad.Base (TCM)+import qualified Agda.Syntax.Internal as SI+import qualified Agda.Syntax.Common   as SC+import Agda.TypeChecking.Monad (MonadTCM, reportSDoc)+import Agda.TypeChecking.Pretty as P -data Relevancy-  = Irr-  | Rel-  | DontKnow-  deriving (Eq, Ord, Show)+#include "../../undefined.h"+import Agda.Utils.Impossible -isIrr :: Relevancy -> Bool+isIrr :: Relevance -> Bool isIrr Irr      = True isIrr Rel      = False-isIrr DontKnow = True -isRel :: Relevancy -> Bool+isRel :: Relevance -> Bool isRel = not . isIrr --- | Irrelevancy "and"-(&&-) :: Relevancy -> Relevancy -> Relevancy-Rel      &&- _        = Rel-_        &&- Rel      = Rel-DontKnow &&- a        = a-a        &&- DontKnow = a-Irr      &&- Irr      = Irr -- If both arguments are irrelevant, then surely we-                            -- have something irrelevant.+-- | Relevance "or"+(||-) :: Relevance -> Relevance -> Relevance+Irr      ||- b      = b+_        ||- _      = Rel+infixr 2 ||- +-- | Relevance "and"+(&&-) :: Relevance -> Relevance -> Relevance+Rel      &&- b      = b+_        &&- _      = Irr+infixr 3 &&-+ data ErasureState = ErasureState-  { relevancies :: Map Var [Relevancy]+  { relevancies :: Map Var [Relevance]   , funs        :: Map Var Fun   }  type Erasure = StateT ErasureState  -- | Try to find as many unused variables as possible-erasure :: MonadTCM m => [Fun] -> Compile m [Fun]+erasure :: [Fun] -> Compile TCM [Fun] erasure fs = do-    rels <- flip evalStateT (ErasureState M.empty M.empty) $ do+    orgRel <- gets (relevantArgs . importedModules)+    (rels, erasureState) <- flip runStateT (ErasureState orgRel M.empty) $ do         mapM_ initiate fs         fu <- gets funs-        M.mapKeys (fromJust . flip M.lookup fu) <$> step-    fmap concat $ mapM (\f -> check f (M.lookup f rels)) fs+        M.mapKeys (fromMaybe __IMPOSSIBLE__ . flip M.lookup fu) <$> step 1+    modifyEI $ \s -> s { relevantArgs = M.mapKeys funName rels }+    concat <$> mapM (\f -> map (rem (relevancies erasureState)) <$> check f (M.lookup f rels)) fs   where++    rem rels f@Fun{} = f { funExpr = removeUnused rels (funExpr f) }+    rem _    f       = f     -- | Perform the worker//wrapper transform-    check :: MonadTCM m => Fun -> Maybe [Relevancy] -> Compile m [Fun]+    check :: Fun -> Maybe [Relevance] -> Compile TCM [Fun]     -- If the function is already marked as to inline we don't need to create a     -- new function. Also If all arguments are relevant there is nothing to do.-    check f (Just rs) | any isIrr rs && not (funInline f) = do-        f' <- newName+    check f@Fun{} (Just rs) | any isIrr rs && not (funInline f) = do+        f' <- (funName f ++) <$> newName         let args' = pairwiseFilter (map isRel rs) (funArgs f)             subs  = pairwiseFilter (map isIrr rs) (funArgs f)             e'    = foldr (\v e -> subst v "primUnit" e) (funExpr f) subs         return [ Fun { funInline  = True                      , funName    = funName f+                     , funQName   = funQName f                      , funComment = funComment f                      , funArgs    = funArgs f                      , funExpr    = App f' $ map Var args'                      }                , Fun { funInline  = False                      , funName    = f'+                     , funQName   = Nothing                      , funComment = funComment f ++ " [ERASED]"                      , funArgs    = args'                      , funExpr    = e'@@ -84,20 +96,63 @@                ]     check f _ = return [f] --- | Initiate a function's relevancies (all DontKnow)-initiate :: Monad m => Fun -> Erasure m ()-initiate f@(Fun _ name _ args _) =-    modify $ \s -> s { relevancies = M.insert name (replicate (length args) DontKnow) (relevancies s)+removeUnused :: Map Var [Relevance] -> Expr -> Expr+removeUnused rels t = let rem = removeUnused rels+                       in case t of+    Var _         -> t+    Lit _         -> t+    Lam v e       -> Lam v (rem e)+    Con tag qn es -> Con tag qn (map rem es)+    App v es      -> case M.lookup v rels of+       Just re -> App v $ zipWith (\r x -> if isIrr r then UNIT else rem x)+                                  (re ++ repeat Rel) es+       Nothing    -> App v $ map rem es+    Case e brs    -> Case (rem e) (map (\br -> br {brExpr = rem $ brExpr br}) brs)+    If a b c      -> If (rem a) (rem b) (rem c)+    Let v e1 e2   -> lett v (rem e1) (rem e2)+    Lazy e        -> lazy (rem e)+    UNIT          -> t+    IMPOSSIBLE    -> t++-- | Initiate a function's relevancies+initiate :: Fun -> Erasure (Compile TCM) ()+initiate f@(Fun _ name mqname _ args _) = do+    let rels = replicate (length args) Irr+    modify $ \s -> s { relevancies = M.insert name rels (relevancies s)                      , funs        = M.insert name f (funs s)                      }-initiate (EpicFun {})            = return ()+initiate f@(EpicFun {funName = name, funQName = mqname}) = case mqname of+    Just qn -> do+        ty <- lift $ getType qn+        let rels = initialRels ty Rel+        return ()+        modify $ \s -> s { relevancies = M.insert name rels (relevancies s)+                         , funs        = M.insert name f (funs s)+                         }+    Nothing -> return () +initialRels :: SI.Type -> Relevance -> [Relevance]+initialRels ty rel =+    case SI.unEl ty of+        SI.Pi  a b -> mkRel a : initialRels (SI.unAbs b) rel+        _       -> []+  where+    mkRel :: SC.Arg SI.Type -> Relevance+    mkRel a | ignoreForced (SC.argRelevance a) = Irr+    mkRel a = case SI.unEl (SC.unArg a) of+       SI.Sort _ -> Irr+       _         -> rel++ignoreForced :: SC.Relevance -> Bool+ignoreForced SC.Relevant = False+ignoreForced _           = True+ -- | Calculate if a variable is relevant in an expression-relevant :: (Functor m, Monad m) => Var -> Expr -> Erasure m Relevancy+relevant :: (Functor m, Monad m) => Var -> Expr -> Erasure m Relevance relevant var expr = case expr of     Var v  | v == var  -> return Rel            | otherwise -> return Irr-    Lit _l       -> return Irr+    Lit _l      -> return Irr     Lam _ e     -> relevant var e     Con _ _ es  -> relevants var es     App v es | v == var  -> return Rel@@ -106,28 +161,55 @@                 mvrs <- gets (M.lookup v . relevancies)                 case mvrs of                   Nothing  -> relevants var es-                  Just vrs -> relevants var-                            $ pairwiseFilter (map isRel vrs ++ repeat True {- Needs ETA expansion -}) es-    Case e brs  -> (&&-) <$> relevant var e  <*> relevants var (map brExpr brs)+                  Just vrs ->+                      relevants var+                        $ map snd+                        $ filter ((==) Rel . fst)+                        $ zip (vrs ++ repeat Rel) es+                      -- foldr (||-) Irr <$> zipWith (&&-) (vrs ++ repeat Rel) <$> mapM (relevant var) es+    -- {-+    Case e [br@Branch{}] -> do+        cvars <- foldr (||-) Irr <$> mapM (flip relevant $ brExpr br) (brVars br)+        vare  <- relevant var e+        varbr <- relevant var (brExpr br)+        return ((vare &&- cvars) ||- varbr)+    -- -}+    Case e brs  -> (||-) <$> relevant var e  <*> relevants var (map brExpr brs)     If a b c    -> relevants var [a,b,c]-    Let _ e1 e2 -> (&&-) <$> relevant var e1 <*> relevant var e2+    Let x e1 e2 -> (||-) <$> ((&&-) <$> relevant var e1 <*> relevant x e2) <*> relevant var e2     Lazy e      -> relevant var e     UNIT        -> return Irr     IMPOSSIBLE  -> return Irr   where-    relevants :: (Functor m, Monad m) => Var -> [Expr] -> Erasure m Relevancy-    relevants v es = foldM (\x y -> return $ x &&- y) Irr =<< mapM (relevant v) es+    relevants :: (Functor m, Monad m) => Var -> [Expr] -> Erasure m Relevance+    relevants v [] = return Irr+    relevants v (e : es) = do+      r <- relevant v e+      case r of+        Rel -> return r+        _   -> relevants v es+    -- relevants v es = return . foldr (\x y -> x ||- y) Irr =<< mapM (relevant v) es --- | Try to find a fixpoint for all the functions relevancy.-step :: (Monad m, Functor m) => Erasure m (Map Var [Relevancy])-step = do+-- | Try to find a fixpoint for all the functions relevance.+step :: Integer -> Erasure (Compile TCM) (Map Var [Relevance])+step nrOfLoops = do     s  <- get-    rels <- forM (M.toList (relevancies s)) $ \(v, _) -> do-               let f = fromJust $ M.lookup v (funs s)-               (,) v <$> mapM (flip relevant (funExpr f)) (funArgs f)-    let relsm = M.fromList rels+    newRels <- (M.fromList <$>) $ forM (M.toList (funs s)) $ \(v, f) -> ((,) v <$>) $ do+               let funRels = fromMaybe __IMPOSSIBLE__ $ M.lookup v (relevancies s)+               case f of+                  EpicFun{} -> return funRels+                  Fun{} -> do+                     forM (zip (funArgs f) (funRels ++ repeat Rel)) $ \ (x, rel) -> case rel of+                        Rel -> return Rel+                        Irr -> do+                          lift $ lift $ reportSDoc "epic.erasure" 10 $ P.text "running erasure:" P.<+> (P.text . show) (funQName f)+                          relevant x (funExpr f)+    let relsm = newRels `M.union` relevancies s     if relevancies s == relsm-       then return relsm+       then return newRels        else do-           put s {relevancies = relsm}-           step+         put s {relevancies = relsm}+         step (nrOfLoops + 1)++diff :: (Ord k, Eq a) => Map k a -> Map k a -> [(k,(a,a))]+diff m1 m2 = catMaybes $ zipWith (\(k, x) (_, y) -> if x == y then Nothing else Just (k, (x, y))) (M.toList m1) (M.toList m2)

+ src/full/Agda/Compiler/Epic/ForceConstrs.hs view

@@ -0,0 +1,75 @@+-- | Remove forced arguments from constructors.+{-# LANGUAGE CPP #-}+module Agda.Compiler.Epic.ForceConstrs where++import Control.Applicative+import Control.Monad.Trans++import Agda.Compiler.Epic.AuxAST+import Agda.Compiler.Epic.CompileState+import Agda.Compiler.Epic.Interface++import qualified Agda.Syntax.Common   as S+import qualified Agda.Syntax.Internal as T+import Agda.TypeChecking.Monad (TCM, reportSDoc)+import Agda.TypeChecking.Pretty++#include "../../undefined.h"+import Agda.Utils.Impossible++-- | Check which arguments are forced+makeForcedArgs :: T.Type -> ForcedArgs+makeForcedArgs (T.El _ term) = case term of+    T.Pi  arg ab  -> isRel arg : makeForcedArgs (T.unAbs ab)+    _ -> []+  where+    isRel :: S.Arg T.Type -> Forced+    isRel arg = case S.argRelevance arg of+      S.Relevant   -> NotForced+      S.Irrelevant -> Forced+      S.NonStrict  -> Forced -- can never be executed+      S.Forced     -> Forced -- It can be inferred++-- | Remove forced arguments from constructors and branches+forceConstrs :: [Fun] -> Compile TCM [Fun]+forceConstrs fs = mapM forceFun fs++forceFun :: Fun -> Compile TCM Fun+forceFun e@(EpicFun{}) = return e+forceFun (Fun inline name qname comment args expr) =+    Fun inline name qname comment args <$> forceExpr expr+  where+    -- | Remove all arguments to constructors that we don't need to store in an+    --   expression.+    forceExpr :: Expr -> Compile TCM Expr+    forceExpr expr = case expr of+        Var v        -> return $ Var v+        Lit l        -> return $ Lit l+        Lam v e      -> Lam v <$> forceExpr e+        Con tag q es -> do+            -- We only need to apply the non-forced arguments+            forcArgs <- getForcedArgs q+            return $ Con tag q $ notForced forcArgs es+        App v es     -> App v <$> mapM forceExpr es+        Case e bs    -> Case <$> forceExpr e <*> mapM forceBranch bs+        Let v e e'   -> lett v <$> forceExpr e <*> forceExpr e'+        If a b c     -> If <$> forceExpr a <*> forceExpr b <*> forceExpr c+        Lazy e       -> Lazy <$> forceExpr e+        UNIT         -> return expr+        IMPOSSIBLE   -> return expr++    -- | Remove all the arguments that don't need to be stored in the constructor+    --   For the branch+    forceBranch :: Branch -> Compile TCM Branch+    forceBranch br = case br of+        Branch  tag name vars e -> do+            ir <- getForcedArgs name+            let vs = notForced ir vars+                subs = forced ir vars++            e'' <- if all (`notElem` fv e) subs+                  then return e+                  else __IMPOSSIBLE__ -- If so, the removal of forced args has gone wrong+            Branch tag name vs <$> forceExpr e''+        BrInt i e -> BrInt i <$> forceExpr e+        Default e -> Default <$> forceExpr e

src/full/Agda/Compiler/Epic/Forcing.hs view

@@ -1,4 +1,4 @@-{-# LANGUAGE CPP #-}+{-# LANGUAGE CPP, ScopedTypeVariables #-} module Agda.Compiler.Epic.Forcing where  import Control.Applicative@@ -6,96 +6,66 @@ import Control.Monad import Control.Monad.State import Control.Monad.Trans-import Data.List++import Data.Char+import Data.List hiding (sort) import qualified Data.Map as M import Data.Maybe  import Agda.Syntax.Common-import Agda.Syntax.Internal-import Agda.TypeChecking.CompiledClause+import qualified Agda.Syntax.Internal as SI+import Agda.Syntax.Literal+import Agda.Syntax.Position(noRange)+import Agda.Syntax.Internal(Tele(..), Telescope, Term, Abs(..), unAbs, absName, Type, Args, QName, unEl) import Agda.TypeChecking.Monad import Agda.TypeChecking.Rules.LHS.Unify-import Agda.TypeChecking.Substitute-import Agda.TypeChecking.Pretty+import Agda.TypeChecking.Rules.LHS.Instantiate+import Agda.TypeChecking.Substitute (raiseFrom, raise, substs, apply, TelV(..))+import qualified Agda.TypeChecking.Substitute as S+import Agda.TypeChecking.Pretty as P import Agda.TypeChecking.Reduce import Agda.TypeChecking.Telescope import Agda.Utils.List+import Agda.Utils.Monad+import Agda.Utils.Permutation import Agda.Utils.Size -import Agda.Compiler.Epic.CompileState hiding (conPars)-import Agda.Compiler.Epic.AuxAST(pairwiseFilter)+import Agda.Compiler.Epic.AuxAST+import Agda.Compiler.Epic.CompileState+import Agda.Compiler.Epic.Epic+import Agda.Compiler.Epic.Interface+import qualified Agda.Compiler.Epic.FromAgda as FA  #include "../../undefined.h" import Agda.Utils.Impossible --- | Replace the uses of forced variables in a CompiledClauses with the function---   arguments that they correspond to.---   Note that this works on CompiledClauses where the term's variable indexes---   have been reversed, which means that the case variables match the variables---   in the term.-removeForced :: MonadTCM m => CompiledClauses -> Type -> Compile m CompiledClauses-removeForced cc typ = do-  TelV tele _ <- lift $ telView typ-  remForced cc tele --- | Returns the type of a constructor given its name-constrType :: MonadTCM m => QName -> Compile m Type-constrType q = do-    map <- lift (gets (sigDefinitions . stImports))-    return $ maybe __IMPOSSIBLE__ defType (M.lookup q map)+-- | Returns how many parameters a datatype has+dataParameters :: QName -> Compile TCM Nat+dataParameters = lift . dataParametersTCM  -- | Returns how many parameters a datatype has-dataParameters :: MonadTCM m => QName -> Compile m Nat-dataParameters name = do-    m <- lift (gets (sigDefinitions . stImports))+dataParametersTCM :: QName -> TCM Nat+dataParametersTCM name = do+    m <- (gets (sigDefinitions . stImports))     return $ maybe __IMPOSSIBLE__ (defnPars . theDef) (M.lookup name m)   where     defnPars :: Defn -> Nat     defnPars (Datatype {dataPars = p}) = p     defnPars (Record   {recPars  = p}) = p-    defnPars _                         = 0 -- Not so sure about this.---- | Is variable n used in a CompiledClause?-isIn :: MonadTCM m => Nat -> CompiledClauses -> Compile m Bool-n `isIn` Case i brs | n == fromIntegral i = return True-                    | otherwise = n `isInCase` (fromIntegral i, brs)-n `isIn` Done _ t = return $ n `isInTerm` t-n `isIn` Fail     = return $ False--isInCase :: MonadTCM m => Nat -> (Nat, Case CompiledClauses) -> Compile m Bool-n `isInCase` (i, Branches { conBranches    = cbrs-                          , litBranches    = lbrs-                          , catchAllBranch = cabr}) = do-    cbrs' <- (or <$>) $ forM (M.toList cbrs) $ \ (constr, cc) -> do-        if i < n-          then do-            par <- fromIntegral <$> getConPar constr-            (n + par - 1) `isIn` cc-          else n `isIn` cc--    lbrs' <- (or <$>) $ forM (M.toList lbrs) $ \ (_, cc) ->-        (if i < n-           then (n - 1)-           else n) `isIn` cc--    cabr' <- case cabr of-        Nothing -> return False-        Just cc -> n `isIn` cc-    return (cbrs' || lbrs' || cabr')+    defnPars d                         = 0 -- error (show d) -- __IMPOSSIBLE__ -- Not so sure about this. +report n s = do+  lift $ reportSDoc "epic.forcing" n s -isInTerm :: Nat -> Term -> Bool-n `isInTerm` term = let recs = any (isInTerm n . unArg) in case term of-   Var i as -> i == n || recs as-   Lam _ ab -> (n+1) `isInTerm` absBody ab-   Lit _    -> False-   Def _ as -> recs as-   Con _ as -> recs as-   Pi a b   -> n `isInTerm` unEl (unArg a) || (n+1) `isInTerm` unEl (absBody b)-   Fun a b  -> n `isInTerm` unEl (unArg a) || n `isInTerm` unEl b-   Sort sor -> False -- ?-   MetaV meta as -> False -- can't occur?-   DontCare -> False+piApplyM' :: Type -> Args -> TCM Type+piApplyM' t as = do+ {- reportSDoc "" 10 $ vcat+    [ text "piApplyM'"+    , text "type: " <+> prettyTCM t+    , text "args: " <+> prettyTCM as+    ]-}+  piApplyM t as  {- | insertTele i xs t tele@@ -112,287 +82,228 @@ we raise the type since we have added xs' new bindings before Gamma, and as can only bind to Gamma. -}-insertTele :: MonadTCM m-            => Int        -- ^ ABS `pos` in tele+insertTele ::(QName, Args) -> Int        -- ^ ABS `pos` in tele             -> Maybe Type -- ^ If Just, it is the type to insert patterns from                           --   is nothing if we only want to delete a binding.             -> Term       -- ^ Term to replace at pos             -> Telescope  -- ^ The telescope `tele` where everything is at-            -> Compile m ( Telescope-                         , ( Type-                           , Type+            -> Compile TCM ( Telescope -- Resulting telescope+                           , ( Telescope+                             , Type -- The type at pos in tele+                             , Type -- The return Type of the inserted type+                             )                            )-                         )-                -- ^ Returns (resulting telescope, the type at pos in tele, the-                --   return type of the inserted type).-insertTele 0 ins term (ExtendTel t to) = do+insertTele x 0 ins term (ExtendTel t to) = do     t' <- lift $ normalise t-    let Def st arg = unEl . unArg $ t'+    report 12 $ vcat+      [ text "t' :" <+> prettyTCM t'+      , text "term:" <+> prettyTCM term+      , text "to:"   <+> prettyTCM (unAbs to)+      ]+    (st, arg) <- case SI.unEl . unArg $ t' of+            SI.Def st arg -> return (st, arg)+            s          -> do+              report 10 $ vcat+                [ text "ERROR!!!"+                , text "found: " <+> (text . show) s+                , text "ins"     <+> (prettyTCM . fromMaybe __IMPOSSIBLE__) ins+                ]+              return x     -- Apply the parameters of the type of t     -- Because: parameters occurs in the type of constructors but are not bound by it.     pars <- dataParameters st-    TelV ctele ctyp <- lift $ telView $ maybe (unArg t')-                            (`apply` take (fromIntegral pars) arg) ins+    report 10 $ text "apply in insertTele"+    TelV ctele ctyp <- lift $ telView =<< maybe (return $ unArg t')+                            (`piApplyM'` take (fromIntegral pars) arg) ins      () <- if length (take (fromIntegral pars) arg) == fromIntegral pars         then return ()         else __IMPOSSIBLE__     -- we deal with absBody to directly since we remove t-    return ( ctele +:+  (subst term $ raiseFrom 1 (size ctele) (absBody to))-           , (raise (size ctele) $ unArg t , ctyp)+    return ( ctele +:+  (S.subst term $ S.raiseFrom 1 (size ctele) (unAbs to))+           , (ctele, S.raise (size ctele) $ unArg t , ctyp)            )   where     -- Append the telescope, we raise since we add a new binding and all the previous     -- bindings need to be preserved     (+:+) :: Telescope -> Telescope -> Telescope     EmptyTel       +:+ t2 = t2-    ExtendTel t t1 +:+ t2 = ExtendTel t t1 {absBody = absBody t1 +:+ {-raise 1-} t2 }+    ExtendTel t t1 +:+ t2 = ExtendTel t (Abs (absName t1) $ unAbs t1 +:+ {-raise 1-} t2 ) -- This case is impossible since we are trying to split a variable outside the tele-insertTele n ins term EmptyTel = __IMPOSSIBLE__-insertTele n ins term (ExtendTel x xs) = do-    (xs', typ) <- insertTele (n - 1) ins term (absBody xs)-    return (ExtendTel x xs {absBody = xs'} , typ)+insertTele x n ins term EmptyTel = __IMPOSSIBLE__+insertTele er n ins term (ExtendTel x xs) = do+    (xs', typ) <- insertTele er (n - 1) ins term (unAbs xs)+    return (ExtendTel x $ Abs (absName xs) xs' , typ) -mkCon c n = Con c [ defaultArg $ Var (fromIntegral i) [] | i <- [n - 1, n - 2 .. 0] ]+mkCon c n = SI.Con c [ defaultArg $ SI.Var (fromIntegral i) [] | i <- [n - 1, n - 2 .. 0] ] -unifyI :: MonadTCM m => Telescope -> [Nat] -> Type -> Args -> Args -> Compile m [Maybe Term]+unifyI :: Telescope -> [Nat] -> Type -> Args -> Args -> Compile TCM [Maybe Term] unifyI tele flex typ a1 a2 = lift $ addCtxTel tele $ unifyIndices_ flex typ a1 a2  takeTele 0 _ = EmptyTel-takeTele n (ExtendTel t ts) = ExtendTel t ts {absBody = takeTele (n-1) (absBody ts) }+takeTele n (ExtendTel t ts) = ExtendTel t $ Abs (absName ts) $ takeTele (n-1) (unAbs ts) takeTele _ _ = __IMPOSSIBLE__ --- | Remove forced variables cased on in the current top-level case in the CompiledClauses-remForced :: MonadTCM m-     => CompiledClauses -- ^ Remove cases on forced variables in this-     -> Telescope       -- ^ The current context we are in-     -> Compile m CompiledClauses-remForced ccOrig tele = case ccOrig of-    Case n brs -> do-        -- Get all constructor branches-        cbs <- forM (M.toList $ conBranches brs) $ \(constr, cc) -> do-            par             <- getConPar  constr-            typ             <- constrType constr-            -- Update tele with the telescope from the constructor's type-            (tele', (ntyp, ctyp))   <- insertTele n (Just typ) (mkCon constr par) tele-            ntyp <- lift $ reduce ntyp-            ctyp <- lift $ reduce ctyp-            notForced       <- getIrrFilter constr-            -- Get the variables that are forced, relative to the position after constr-            forcedVars <- filterM ((`isIn` cc) . (flip subtract (fromIntegral $ n + par - 1)))-                        $ pairwiseFilter (map not notForced)-                        $ map fromIntegral [par-1,par-2..0]-            if null forcedVars-                then (,) constr <$> remForced cc tele'-                else do+-- | Main function for removing pattern matching on forced variables+remForced :: [Fun] -> Compile TCM [Fun]+remForced fs = do+    defs <- lift (gets (sigDefinitions . stImports))+    forM fs $ \f -> case f of+        Fun{} -> case funQName f >>= flip M.lookup defs of+            Nothing -> __IMPOSSIBLE__+            Just def -> do+                TelV tele _ <- lift $ telView (defType def)+                report 10 $ vcat+                  [ text "compiling fun" <+> (text . show) (funQName f)+                  ]+                e <- forcedExpr (funArgs f) tele (funExpr f)+                report 10 $ vcat+                  [ text "compilied fun" <+> (text . show) (funQName f)+                  , text "before:" <+> (text . prettyEpic) (funExpr f)+                  , text "after:" <+> (text . prettyEpic) e+                  ]+                return $ f { funExpr = e}+        EpicFun{} -> return f++-- | For a given expression, in a certain telescope (the list of Var) is a mapping+-- of variable name to the telescope.+forcedExpr :: [Var] -> Telescope -> Expr -> Compile TCM Expr+forcedExpr vars tele expr = case expr of+    Var _ -> return expr+    Lit _ -> return expr+    Lam x e -> Lam x <$> rec e -- necessary?+    Con t q es -> Con t q <$> mapM rec es+    App v es -> App v <$> mapM rec es+    If a b c -> If <$> rec a <*> rec b <*> rec c+    Let v e1 e2 -> Let v <$> rec e1 <*> rec e2+    Lazy e -> Lazy <$> rec e+    UNIT   -> return expr+    IMPOSSIBLE -> return expr+    Case v@(Var x) brs -> do+        let n = fromMaybe __IMPOSSIBLE__ $ elemIndex x vars+        (Case v <$>) . forM brs $ \ br -> case br of+            BrInt i e -> do+              (tele'', _) <-  insertTele __IMPOSSIBLE__ n Nothing (SI.Lit (LitChar noRange (chr i))) tele+              BrInt i <$> forcedExpr (replaceAt n vars []) tele'' e++            Default e -> Default <$> rec e+            Branch t constr as e -> do+                typ <- getType constr+                forc <- getForcedArgs constr+                (tele'', (_, ntyp, ctyp)) <- insertTele __IMPOSSIBLE__ n (Just typ)+                                                        (mkCon constr (length as)) tele+                ntyp <- lift $ reduce ntyp+                ctyp <- lift $ reduce ctyp++                if null (forced forc as)+                  then Branch t constr as <$> forcedExpr (replaceAt n vars as) tele'' e+                  else do+                    -- unify the telescope type with the return type of the constructor                     unif <- case (unEl ntyp, unEl ctyp) of-                        (Def st a1, Def st' a2) | st == st' -> do+                        (SI.Def st a1, SI.Def st' a2) | st == st' -> do                             typPars <- fromIntegral <$> dataParameters st-                            setType <- constrType st-                            {--                                We are splitting on C xs-                                we know that C : ts -> T ss ; for some T-                                we also know from tele that we are splitting on T as-                                we want to unify ss with as, but not taking into account-                                the Data parameters to T.-                            -}-                            unifyI (takeTele (n + par) tele')-                                   (map fromIntegral [0 .. n + par]) -- Don't unify the constructor arguments+                            setType <- getType st+                            report 10 $ vcat+                              [ text "ntyp:" <+> prettyTCM ntyp+                              , text "ctyp:" <+> prettyTCM ctyp+                              ]+                            unifyI (takeTele (n + length as) tele'')+                                   (map fromIntegral $ [0 .. n + length as])                                    (setType `apply` take typPars a1)                                    (drop typPars a1)                                    (drop typPars a2)-                        x -> __IMPOSSIBLE__-                    -- we calculate the new tpos from n (the old one) by adding-                    -- how many more bindings we have-                    (,) constr <$> replaceForced (fromIntegral $ n + par, tele')-                                                 forcedVars-                                                 (cc, unif)--        lbs <- forM (M.toList $ litBranches brs) $ \(lit, cc) -> do-            -- We have one less binding-            (newTele, _) <- insertTele n Nothing (Lit lit) tele-            (,) lit <$>  remForced cc newTele--        cabs <- case catchAllBranch brs of-            Nothing -> return Nothing-            Just cc -> Just <$> remForced cc tele--        return $ Case n brs { conBranches = M.fromList cbs-                            , litBranches = M.fromList lbs-                            , catchAllBranch = cabs }--    Done n t   -> return $ Done n t-    Fail       -> return Fail--data FoldState = FoldState-  { clauseToFix  :: CompiledClauses-  , clausesAbove :: CompiledClauses -> CompiledClauses-  , unification  :: [Maybe Term]-  , theTelescope :: Telescope-  , telePos      :: Nat-  } deriving Show---- Some utility functions--foldM' :: Monad m => a -> [b] -> (a -> b -> m a) -> m a-foldM' z xs f = foldM f z xs--lift2 :: (MonadTrans t, Monad (t1 m), MonadTrans t1, Monad m) => m a -> t (t1 m) a-lift2 = lift . lift--modifyM :: (MonadState a m) => (a -> m a) -> m ()-modifyM f = get >>= f >>= put -- (>>= put) . (get >>=)---- | replaceForced (tpos, tele) forcedVars (cc, unification)---   For each forceVar dig out the corresponding case and continue to remForced.-replaceForced :: MonadTCM m-              => (Nat, Telescope) -> [Nat] -> (CompiledClauses, [Maybe Term])-              -> Compile m CompiledClauses-replaceForced (telPos, tele) forcedVars (cc, unif) = do-    let origSt = FoldState-                  { clauseToFix  = cc-                  , clausesAbove = id-                  , unification  = unif-                  , theTelescope = tele-                  , telePos      = telPos-                  }-    st <- flip execStateT origSt $ forM forcedVars $ \ forcedVar -> do-        unif <- gets unification-        let (caseVar, caseTerm) = findPosition forcedVar unif-        telPos <- gets telePos-        termToBranch (telPos - caseVar - 1) caseTerm forcedVar-    clausesAbove st <$> remForced (clauseToFix st) (theTelescope st)+                        _ -> __IMPOSSIBLE__+                    let+                        lower = map (raise (-1)) . drop 1+                        isOk t = case t of+                          SI.Var n xs | n >= 0 -> all (isOk . unArg) xs+                          SI.Con _ xs -> all (isOk . unArg) xs+                          SI.Def f xs -> all (isOk . unArg) xs+                          _ -> error $ show t+                        subT 0 tel = let ss = [fromMaybe (SI.Var n []) t+                                              | (n , t) <- zip [0..] (unif ++ repeat Nothing)]+                                      in (S.substs ss tel, lower ss)+                        subT n (ExtendTel a t) = let+                               (tb' , ss) = subT (n - 1) (unAbs t)+                               a' | all isOk (take 100 ss) = S.substs ss a+                                  | True    = __IMPOSSIBLE__+                            in (ExtendTel a $ Abs (absName t) tb', lower ss)+                        subT _ _ = __IMPOSSIBLE__+                        (tele'''', _) = subT (n + length as) tele''+                    report 10 $ nest 2 $ vcat+                      [ text "remforced"+                      , text "tele=" <+> prettyTCM tele''+                      , text "tele'=" <+> prettyTCM tele''''+                      , text "unif=" <+> (text . show) unif+                      , text "forced=" <+> (text . show) (forced forc as)+                      , text "constr" <+> prettyTCM constr+                      ]+                    -- replace all forced variables found using the unification+                    Branch t constr as <$>+                        replaceForced (replaceAt n vars as, reverse $ take n vars ++ as)+                                      (tele'''') (forced forc as) unif e+    _ -> __IMPOSSIBLE__   where-    {--      In this function the following de Bruijn is:-        forcedVar : Relative-        caseVar : Absolute-        telePos : Absolute-    -}-    termToBranch :: MonadTCM m => Nat -> Term -> Nat -> StateT FoldState (Compile m) ()-    termToBranch caseVar caseTerm forcedVar = case caseTerm of-        Var i _ | i == forcedVar -> do-            telPos <- gets telePos-            let sub = [0..telPos - forcedVar - 2] ++ [caseVar] ++ [telPos - forcedVar..]-            modifyM $ \ st -> do-                newClauseToFix <- substCC sub (clauseToFix st)-                return st-                    { clauseToFix = newClauseToFix-                    , unification = substs (map (flip Var []) sub) (unification st)-                    }-                -- This is impossible since we have already looked and it should-                -- be the correct Var-                | otherwise -> __IMPOSSIBLE__-        Con c args -> do-            telPos <- gets telePos-            let (nextCaseVarInCon, nextCaseTerm) = findPosition forcedVar (map (Just . unArg) args)-                nextCaseVar = nextCaseVarInCon + caseVar-                newBinds    = fromIntegral $ length args - 1-                -- we have added newBinds new bindings and removed one before telePos-                nextTelePos = telPos + newBinds-            ctyp <- lift (constrType c)--            modifyM $ \ st -> do-                (newTele , _) <- lift $ insertTele (fromIntegral caseVar) (Just ctyp)-                                        (mkCon c (length args)) (theTelescope st)-                -- We have to update the unifications-list so that we don't try-                -- to dig out the same again later.-                let newUnif = raiseFrom (telPos - caseVar) newBinds $-                        replaceAt (fromIntegral $ telPos - caseVar - 1)-                                  (unification st)-                                  (reverse $ map (Just . unArg) args)-                                  -- The variables in the unification-list is-                                  -- relative so we need to reverse the args-                                  -- so they get in the right place.-                return st-                    { clauseToFix  = raiseFromCC caseVar newBinds-                                                 (substCCBody caseVar-                                                 (Con c $ map (defaultArg . flip Var [])-                                                              [caseVar .. caseVar + newBinds])-                                                 (clauseToFix st))-                    , theTelescope = newTele-                    , unification  = newUnif-                    , telePos      = nextTelePos-                    }-            st <- get-            termToBranch nextCaseVar nextCaseTerm forcedVar-            modify $ \ st -> st-                { clausesAbove = Case (fromIntegral caseVar) . conCase c . (clausesAbove st)-                }-        _ -> __IMPOSSIBLE__+    rec = forcedExpr vars tele --- Note: Absolute positions-raiseFromCC :: Nat -> Nat -> CompiledClauses -> CompiledClauses-raiseFromCC from add  cc = case cc of-    Case n (Branches cbr lbr cabr) -> Case (fromIntegral $ raiseN from add (fromIntegral n)) $-                                           Branches (M.map rec cbr)-                                                    (M.map rec lbr)-                                                    (fmap  rec cabr)-    Done i t -> Done (i + fromIntegral add) $ raiseFrom from add t-    Fail     -> Fail+-- | replace the forcedVar with pattern matching from the outside.+replaceForced :: ([Var],[Var]) -> Telescope -> [Var] -> [Maybe SI.Term] -> Expr -> Compile TCM Expr+replaceForced (vars,_) tele [] _ e = forcedExpr vars tele e+replaceForced (vars,uvars) tele (fvar : fvars) unif e = do+    let n = fromMaybe __IMPOSSIBLE__ $ elemIndex fvar uvars+    mpos <- findPosition (fromIntegral n) unif+    case mpos of+        Nothing -> case unif !! n of+            Nothing | fvar `notElem` fv e ->+              replaceForced (vars, uvars) tele fvars unif e+            Nothing -> do+              report 10 $ vcat+                [ text "failure comming!"+                , text "unif" <+> (text . show) unif+                , text "n" <+> (text . show) n+                , text "fvar" <+> (text fvar)+                , text "fv" <+> (text . show) (fv e)+                ]+              __IMPOSSIBLE__+            Just t  -> do+                v <- newName+                te <- FA.substTerm uvars t+                subst fvar v <$> replaceForced (vars, uvars)+                                               tele fvars unif (Let v te e)+        Just (pos , term) -> do+            (build, v) <- buildTerm (uvars !! fromInteger pos) (fromIntegral n) term+            build . subst fvar v <$> replaceForced (vars, uvars) tele fvars unif+                                     e   where-    rec = raiseFromCC from add-    raiseN :: Nat -> Nat -> Nat -> Nat-    raiseN from add n | from <= n = n + add-                      | otherwise = n+    sub fvar v = map $ \x -> if x == fvar then v else x --- | Substitute with the Substitution, this will adjust with the new bindings in the---   CompiledClauses-substCC :: MonadTCM m => [Nat] -> CompiledClauses -> StateT FoldState (Compile m) CompiledClauses-substCC ss cc = case cc of-    Done i t -> do-        return $ Done i (substs (map (flip Var []) ({-reverse $ take i -} ss)) t)-    Fail     -> return Fail-    Case n brs -> do-        {--          In a Case split, if we should change n to m, then all the binders in-          this pattern should also change from being based on n to be based on m.-        -}-        cbs <- forM (M.toList $ conBranches brs) $ \ (c, br) -> do-            nargs <- lift2 $ constructorArity c-            let delta = (ss !! n) - fi n-                ss'   = take n ss-                      ++ [fi n + delta .. fi n + delta + nargs - 1]-                      ++ map (+ (nargs - 1)) (drop (n+1) ss)-            (,) c <$> substCC ss' br+-- | Given a term containg the forced var, dig out the variable by inserting+-- the proper case-expressions.+buildTerm :: Var -> Nat -> Term -> Compile TCM (Expr -> Expr, Var)+buildTerm var idx (SI.Var i _) | idx == i = return (id, var)+buildTerm var idx (SI.Con c args) = do+    vs <- replicateM (length args) newName+    (pos , arg) <- fromMaybe __IMPOSSIBLE__ <$> findPosition idx (map (Just . unArg) args)+    (fun' , v) <- buildTerm (vs !! fromInteger pos) idx arg+    tag <- getConstrTag c+    let fun e = casee (Var var) [Branch tag c vs e]+    return (fun . fun' , v)+buildTerm _ _ _ = __IMPOSSIBLE__ -        lbs <- forM (M.toList $ litBranches brs) $ \ (l, br) -> do-            -- We have one less binder here-            (,) l <$> substCC (replaceAt n ss []) br -        cabs <- case catchAllBranch brs of-            Nothing -> return Nothing-            Just br -> Just <$> substCC ss br--        return $ Case (fromIntegral (ss !! n))-                  Branches { conBranches    = M.fromList cbs-                           , litBranches    = M.fromList lbs-                           , catchAllBranch = cabs-                           }-  where-    fi = fromIntegral---- | Substitute variable n for term t in the body of cc-substCCBody :: Nat -> Term -> CompiledClauses -> CompiledClauses-substCCBody n t cc = substsCCBody (vs [0..n - 1] ++ [t] ++ vs [n + 1..]) cc-  where vs = map (flip Var [])---- | Perform a substitution in the body of cc-substsCCBody :: [Term] -> CompiledClauses -> CompiledClauses-substsCCBody ss cc = case cc of-    Case n brs -> Case n (substsCCBody ss <$> brs)-    Done i t -> Done i (substs ss t)-    Fail     -> Fail- -- | Find the location where a certain Variable index is by searching the constructors --   aswell. i.e find a term that can be transformed into a pattern that contains the --   same value the index. This fails if no such term is present.-findPosition :: Nat -> [Maybe Term] -> (Nat, Term)-findPosition var ts = let Just n = findIndex (maybe False pred) ts-                       in (fromIntegral n , fromJust $ ts !! n)+findPosition :: Nat -> [Maybe SI.Term] -> Compile TCM (Maybe (Nat, SI.Term))+findPosition var ts = (listToMaybe . catMaybes <$>) . forM (zip [0..] ts) $ \ (n, mt) -> do+    ifM (maybe (return False) pred mt)+        (return (Just (n, fromMaybe __IMPOSSIBLE__ mt)))+        (return Nothing)   where-    pred :: Term -> Bool+    pred :: Term -> Compile TCM Bool     pred t = case t of-      Var i _ | var == i -> True-      Con _ args         -> any (pred . unArg) args-      _                  -> False+      SI.Var i _ | var == i -> return True+      SI.Con c args         -> do+          forc <- getForcedArgs c+          or <$> mapM (pred . unArg) (notForced forc args)+      _                  -> return False

src/full/Agda/Compiler/Epic/FromAgda.hs view

@@ -18,78 +18,94 @@ import qualified Agda.Syntax.Literal  as TL import qualified Agda.TypeChecking.CompiledClause as CC import Agda.TypeChecking.Monad+import Agda.TypeChecking.Level (reallyUnLevelView) import qualified Agda.TypeChecking.Substitute as S+import Agda.TypeChecking.Pretty  import Agda.Compiler.Epic.AuxAST-import Agda.Compiler.Epic.CompileState hiding (conPars)-import Agda.Compiler.Epic.Forcing+import Agda.Compiler.Epic.CompileState+import Agda.Compiler.Epic.Interface+import Agda.Compiler.Epic.Static +import Agda.Compiler.Epic.Epic+ #include "../../undefined.h" import Agda.Utils.Impossible  -- | Convert from Agda's internal representation to our auxiliary AST.-fromAgda :: MonadTCM m => Maybe T.Term -> [(QName, Definition)] -> Compile m [Fun]+fromAgda :: Maybe T.Term -> [(QName, Definition)] -> Compile TCM [Fun] fromAgda msharp defs = catMaybes <$> mapM (translateDefn msharp) defs  -- | Translate an Agda definition to an Epic function where applicable-translateDefn :: MonadTCM m => Maybe T.Term -> (QName, Definition) -> Compile m (Maybe Fun)-translateDefn msharp (n, defini) = let n' = unqname n in case theDef defini of+translateDefn :: Maybe T.Term -> (QName, Definition) -> Compile TCM (Maybe Fun)+translateDefn msharp (n, defini) =+  let n' = unqname n+      epDef = compiledEpic $ defCompiledRep defini+  in case theDef defini of     d@(Datatype {}) -> do -- become functions returning unit         vars <- replicateM (fromIntegral $ dataPars d + dataIxs d) newName-        return . return $ Fun True n' ("datatype: " ++ show n) vars UNIT+        return . return $ Fun True n' (Just n) ("datatype: " ++ show n) vars UNIT     f@(Function{}) -> do-        irrF <- gets irrFilters-        let len   = length . clausePats . translatedClause . head .  funClauses $ f+        let projArgs = maybe 0 (pred . snd) (funProjection f)+        ccs  <- reverseCCBody projArgs <$> normaliseStatic (funCompiled f)+        let len   = (+ projArgs) . length . clausePats . head .  funClauses $ f             toEta = fromIntegral (arity (defType defini)) - len-            ccs   = reverseCCBody $ funCompiled f-        forcing <- lift $ gets (optForcing . stPersistentOptions)-        funComp <- if forcing-                    then removeForced ccs (defType defini)-                    else return ccs-        return <$> (etaExpand toEta =<< compileClauses n len funComp)+        -- forcing <- lift $ gets (optForcing . stPersistentOptions)+        lift $ reportSDoc "epic.fromagda" 5 $ text "compiling fun:" <+> prettyTCM n+        lift $ reportSDoc "epic.fromagda" 5 $ text "len:" <+> (text . show) len+        lift $ reportSDoc "epic.fromagda" 5 $ text "pats:" <+> (text . show) (clausePats+                    $ head $ funClauses f)+        modify $ \s -> s {curFun = show n}+        lift $ reportSDoc "epic.fromagda" 5 $ text "ccs: " <+> (text . show) ccs+        res <- return <$> (etaExpand toEta =<< compileClauses n len ccs)+        pres <- case res of+          Nothing -> return Nothing+          Just  c -> return <$> prettyEpicFun c+        lift $ reportSDoc "" 5 $ text $ show pres -- (fmap prettyEpicFun res)+        return res     Constructor{} -> do -- become functions returning a constructor with their tag         arit <- lift $ constructorArity n         tag   <- getConstrTag n         -- Sharp has to use the primSharp function from AgdaPrelude.e         case msharp of-          Just (T.Def sharp []) | sharp == n -> return <$> mkFun n' "primSharp" 3+          Just (T.Def sharp []) | sharp == n -> return <$> mkFun n n' "primSharp" 3           _    -> return <$> mkCon n tag arit     r@(Record{}) -> do         vars <- replicateM (fromIntegral $ recPars r) newName-        return . return $ Fun True n' ("record: " ++ show n) vars UNIT+        return . return $ Fun True n' (Just n) ("record: " ++ show n) vars UNIT     a@(Axiom{}) -> do -- Axioms get their code from COMPILED_EPIC pragmas-        case axEpDef a of-            Nothing -> return . return $ EpicFun n' ("AXIOM_UNDEFINED: " ++ show n)+        case epDef of+            Nothing -> return . return $ EpicFun n' (Just n) ("AXIOM_UNDEFINED: " ++ show n)                 $ "() -> Any = lazy(error \"Axiom " ++ show n ++ " used but has no computation\")"-            Just x  -> return . return $ EpicFun n' ("COMPILED_EPIC: " ++ show n) x+            Just x  -> return . return $ EpicFun n' (Just n) ("COMPILED_EPIC: " ++ show n) x     p@(Primitive{}) -> do -- Primitives use primitive functions from AgdaPrelude.e of the same name.                           -- Hopefully they are defined!       let ar = fromIntegral $ arity $ defType defini-      return <$> mkFun n' (primName p) ar+      return <$> mkFun n n' (primName p) ar   where-    mkFun = mkFunGen apps ("primitive: " ++)+    mkFun q = mkFunGen q apps ("primitive: " ++)     mkCon q tag ari = do         let name = unqname q-        mkFunGen (flip Con q) (const $ "constructor: " ++ show q) name tag ari-    mkFunGen :: Monad m-            => (name -> [Expr] -> Expr) -- ^ combinator+        mkFunGen q (flip Con q) (const $ "constructor: " ++ show q) name tag ari+    mkFunGen :: QName                    -- ^ Original name+            -> (name -> [Expr] -> Expr) -- ^ combinator             -> (name -> String)         -- ^ make comment             -> Var                      -- ^ Name of the function             -> name                     -- ^ Primitive function name             -> Int                      -- ^ Arity ofthe function-            -> Compile m Fun            -- ^ Result?-    mkFunGen comb sh name primname arit = do+            -> Compile TCM Fun            -- ^ Result?+    mkFunGen qn comb sh name primname arit = do         vars <- replicateM arit newName-        return $ Fun True name (sh primname) vars (comb primname (map Var vars))+        return $ Fun True name (Just qn) (sh primname) vars (comb primname (map Var vars)) -    etaExpand :: MonadTCM m => Int -> Fun -> Compile m Fun-    etaExpand num fun = do-        names <- replicateM num newName+    etaExpand :: Int -> Fun -> Compile TCM Fun+    etaExpand num fun = return fun -- do+{-        names <- replicateM num newName         return $ fun             { funExpr = funExpr fun @@ names             , funArgs = funArgs fun ++ names             }-+-}     (@@) :: Expr -> [Var] -> Expr     e @@ [] = e     e @@ vs = let ts = map Var vs in case e of@@ -101,7 +117,7 @@       App var es       -> App var (es ++ ts)       Case expr bs     -> Case expr (map (flip appBranch vs) bs)       If ea eb ec      -> If ea (eb @@ vs) (ec @@ vs)-      Let var el e'    -> Let var el (e' @@ vs)+      Let var el e'    -> lett var el (e' @@ vs)       Lazy e'          -> Lazy (e' @@ vs)       Lit _lit         -> IMPOSSIBLE -- Right?       UNIT             -> IMPOSSIBLE@@ -110,12 +126,14 @@     appBranch :: Branch -> [Var] -> Branch     appBranch b vs = b {brExpr = brExpr b @@ vs} -reverseCCBody :: CC.CompiledClauses -> CC.CompiledClauses-reverseCCBody cc = case cc of-    CC.Case n (CC.Branches cbr lbr cabr) -> CC.Case n $ CC.Branches (M.map reverseCCBody cbr)-                                                        (M.map reverseCCBody lbr)-                                                        (fmap  reverseCCBody cabr)-    CC.Done i t -> CC.Done i (S.substs (map (flip T.Var []) (reverse $ take i [0..])) t)+reverseCCBody :: Int -> CC.CompiledClauses -> CC.CompiledClauses+reverseCCBody c cc = case cc of+    CC.Case n (CC.Branches cbr lbr cabr) -> CC.Case (c+n)+        $ CC.Branches (M.map (reverseCCBody c) cbr)+          (M.map (reverseCCBody c) lbr)+          (fmap  (reverseCCBody c) cabr)+    CC.Done i t -> CC.Done i (S.substs (map (flip T.Var [])+                               (reverse $ take (length i) [fromIntegral c..])) t)     CC.Fail     -> CC.Fail  -- | Translate from Agda's desugared pattern matching (CompiledClauses) to our AuxAST.@@ -148,31 +166,30 @@ --   we have to add the catchAllBranch to each inner case (here we are calling --   it omniDefault). To avoid code duplication it is first bound by a let --   expression.-compileClauses :: MonadTCM m-               => QName+compileClauses :: QName                -> Int -- ^ Number of arguments in the definition-               -> CC.CompiledClauses -> Compile m Fun+               -> CC.CompiledClauses -> Compile TCM Fun compileClauses name nargs c = do     let n' = unqname name     vars <- replicateM nargs newName     e    <- compileClauses' vars Nothing c-    return $ Fun False n' ("function: " ++ show name) vars e+    return $ Fun False n' (Just name) ("function: " ++ show name) vars e   where-    compileClauses' :: MonadTCM m => [Var] -> Maybe Var -> CC.CompiledClauses -> Compile m Expr+    compileClauses' :: [Var] -> Maybe Var -> CC.CompiledClauses -> Compile TCM Expr     compileClauses' env omniDefault cc = case cc of         CC.Case n nc -> case length env <= n of            True -> __IMPOSSIBLE__            False -> case CC.catchAllBranch nc of             Nothing -> Case (Var (env !! n)) <$> compileCase env omniDefault n nc             Just de -> do-                var <- newName                 def <- compileClauses' env omniDefault de-                Let var (Lazy def) . Case (Var (env !! n)) <$> compileCase env (Just var) n nc+                bindExpr (lazy def) $ \ var ->+                  Case (Var (env !! n)) <$> compileCase env (Just var) n nc         CC.Done _ t -> substTerm ({- reverse -} env) t         CC.Fail     -> return IMPOSSIBLE -    compileCase :: MonadTCM m => [Var] -> Maybe Var -> Int -> CC.Case CC.CompiledClauses-                -> Compile m [Branch]+    compileCase :: [Var] -> Maybe Var -> Int -> CC.Case CC.CompiledClauses+                -> Compile TCM [Branch]     compileCase env omniDefault casedvar nc = do         cb <- if M.null (CC.conBranches nc)            -- Lit branch@@ -180,12 +197,13 @@                cc' <- compileClauses' (replaceAt casedvar env []) omniDefault cc                case l of                    TL.LitChar _ cha -> return $ BrInt (ord cha) cc'-                   _ -> __IMPOSSIBLE__ -- TODO: Handle other literals+                   -- TODO: Handle other literals+                   _ -> epicError $ "case on literal not supported: " ++ show l            -- Con branch            else forM (M.toList (CC.conBranches nc)) $ \(b, cc) -> do-               par  <- getConPar b+               arit  <- getConArity b                tag  <- getConstrTag b-               vars <- replicateM par newName+               vars <- replicateM arit newName                cc'  <- compileClauses' (replaceAt casedvar env vars) omniDefault cc                return $ Branch tag b vars cc' @@ -197,19 +215,27 @@ -- | Translate the actual Agda terms, with an environment of all the bound variables --   from patternmatching. Agda terms are in de Bruijn so we just check the new --   names in the position.-substTerm :: MonadTCM m => [Var] -> T.Term -> Compile m Expr+substTerm :: [Var] -> T.Term -> Compile TCM Expr substTerm env term = case term of     T.Var ind args -> case length env <= fromIntegral ind of         True  -> __IMPOSSIBLE__         False -> apps (env !! fromIntegral ind) <$> mapM (substTerm env . unArg) args-    T.Lam _ te -> do+    T.Lam _ (Abs _ te) -> do        name <- newName-       Lam name <$> substTerm (name : env) (absBody te)+       Lam name <$> substTerm (name : env) te+    T.Lam _ (NoAbs _ te) -> do+       name <- newName+       Lam name <$> substTerm env te     T.Lit l -> Lit <$> substLit l+    T.Level l -> substTerm env =<< lift (reallyUnLevelView l)     T.Def q args -> do       let name = unqname q       del <- getDelayed q-      f <- apps name <$> mapM (substTerm env . unArg) args+      def <- theDef <$> lift (getConstInfo q)+      let nr = case def of+                Function{funProjection = Just (_ , x)} -> pred x+                _ -> 0+      f <- apps name . (replicate nr UNIT ++) <$> mapM (substTerm env . unArg) args       return $ case del of         True  -> Lazy f         False -> f@@ -217,16 +243,14 @@         let con = unqname q         apps con <$> mapM (substTerm env . unArg) args     T.Pi _ _ -> return UNIT-    T.Fun _ _ -> return UNIT     T.Sort _  -> return UNIT     T.MetaV _ _ -> return UNIT-    T.DontCare  -> return UNIT+    T.DontCare _ -> return UNIT  -- | Translate Agda literals to our AUX definition-substLit :: MonadTCM m => TL.Literal -> Compile m Lit+substLit :: TL.Literal -> Compile TCM Lit substLit lit = case lit of   TL.LitInt    _ i -> return $ LInt i-  TL.LitLevel  _ i -> return $ LInt i   TL.LitString _ s -> return $ LString s   TL.LitChar   _ c -> return $ LChar c   TL.LitFloat  _ f -> return $ LFloat f

+ src/full/Agda/Compiler/Epic/Injection.hs view

@@ -0,0 +1,323 @@+{-# LANGUAGE CPP, TypeOperators, PatternGuards #-}+module Agda.Compiler.Epic.Injection where++import Control.Monad.State++import Data.Function+import Data.Ix+import Data.List+import Data.Map(Map)+import qualified Data.Map as M+import Data.Maybe+import Data.Set(Set)+import qualified Data.Set as S++import Agda.Syntax.Common+import Agda.Syntax.Internal+import Agda.Syntax.Literal+import Agda.TypeChecking.CompiledClause+import Agda.TypeChecking.Monad hiding ((!!!))+import Agda.TypeChecking.Monad.Builtin+import Agda.TypeChecking.Pretty+import Agda.TypeChecking.Reduce+import Agda.TypeChecking.Substitute+import Agda.TypeChecking.Telescope+import Agda.Utils.Monad+import Agda.Utils.Size++import Agda.Compiler.Epic.CompileState+import qualified Agda.Compiler.Epic.FromAgda as FA+import Agda.Compiler.Epic.Interface as Interface++#include "../../undefined.h"+import Agda.Utils.Impossible++-- | Find potentially injective functions, solve constraints to fix some constructor+--   tags and make functions whose constraints are fulfilled injections+findInjection :: [(QName, Definition)] -> Compile TCM [(QName, Definition)]+findInjection defs = do+    funs <- forM defs $ \(name, def) -> case theDef def of+        f@(Function{}) -> isInjective name (funClauses f)+        _              -> return Nothing+    newNames <- M.keys <$> gets (Interface.conArity . curModule)+    injFuns <- solve newNames (catMaybes funs)+    defs' <- forM defs $ \(q, def) -> case q `isIn` injFuns of+        Nothing -> return (q, def)+        Just inj@(InjectiveFun var arity) -> case theDef def of+            f@(Function{})   -> do+                modifyEI $ \s -> s { injectiveFuns = M.insert q inj (injectiveFuns s) }+                let ns = replicate (fromIntegral arity) (Arg NotHidden Relevant "")+                return $ (,) q $ def {theDef = f { funCompiled = Done ns+                                                                      (Var (arity - var - 1) []) } }+            _                -> __IMPOSSIBLE__++    lift $ reportSLn "epic.injection" 10 $ "injfuns: " ++ show injFuns+    return defs'+  where+    q `isIn` funs = case filter (\(nam, _) -> q == nam) funs of+        []   -> Nothing+        (_,x):_  -> Just x++replaceFunCC :: QName -> CompiledClauses -> Compile TCM ()+replaceFunCC name cc = do+    lift $ modify $ \s ->+        s { stSignature = (stSignature s) { sigDefinitions = M.adjust replaceDef name (sigDefinitions (stSignature s)) }+          , stImports   = (stImports   s) { sigDefinitions = M.adjust replaceDef name (sigDefinitions (stImports   s)) }+          }+  where+    replaceDef :: Definition -> Definition+    replaceDef def = case theDef def of+        f@(Function{}) -> def {theDef = f { funCompiled = cc } }+        x                -> __IMPOSSIBLE__++-- | If the pairs of constructor names have the same tags, the function is+--   injective. If Nothing, the function is not injective.+type InjConstraints = Maybe [(QName,QName)]+++isInjective :: QName    -- ^ Name of the function being tested+            -> [Clause] -- ^ The function's clauses+            -> Compile TCM (Maybe ((QName, InjectiveFun)+                                  , [(QName, QName)] -- These construtors should have the same name+                                  ))+isInjective nam []  = return Nothing+isInjective nam cls@(cl : _) = do+    let total = genericLength . clausePats $ cl+    (listToMaybe . catMaybes <$>) . forM [0 .. total - 1] $ \i -> do+        cli <- forM cls $ \ cl -> isInjectiveHere nam i  cl+        let cli' = catMaybes cli+        return $ if length cli == length cli'+             then Just ((nam, InjectiveFun (fromIntegral i) (fromIntegral total)), concat cli')+             else Nothing++remAbs :: ClauseBody -> Term+remAbs b = case b of+    Body t     -> t+    Bind ab    -> remAbs $ absBody ab+    NoBody     -> __IMPOSSIBLE__++isNoBody :: ClauseBody -> Bool+isNoBody b = case b of+    Body t     -> False+    Bind ab    -> isNoBody $ absBody ab+    NoBody     -> True++patternToTerm :: Nat -> Pattern -> Term+patternToTerm n p = case p of+    VarP v          -> Var n []+    DotP t          -> t+    ConP c typ args -> Con c $ zipWith (\ arg t -> arg {unArg = t}) args+                             $ snd+                             $ foldr (\ arg (n, ts) -> (n + nrBinds arg, patternToTerm n arg : ts))+                                     (n , [])+                             $ map unArg args+    LitP l          -> Lit l++nrBinds :: Num i => Pattern -> i+nrBinds p = case p of+    VarP v          -> 1+    DotP t          -> 0+    ConP c typ args -> sum $ map (nrBinds . unArg) args+    LitP l          -> 0++substForDot :: [Arg Pattern] -> Substitution+substForDot ps = map (flip Var []) (makeSubst 0 0 $ reverse $ calcDots ps)+  where+    makeSubst i accum [] = [i + accum ..]+    makeSubst i accum (True  : ps) = makeSubst i (accum +1) ps+    makeSubst i accum (False : ps) = i + accum : makeSubst (i+1) accum ps++    calcDots = concatMap calcDots' . map unArg+    calcDots' p = case p of+        VarP v          -> [False]+        DotP t          -> [True]+        ConP c typ args -> calcDots args+        LitP l          -> [False]++isInjectiveHere :: QName  -- ^ Name of the function being tested+                -> Int    -- ^ The current argument+                -> Clause+                -> Compile TCM InjConstraints+isInjectiveHere nam idx Clause {clauseBody = body} | isNoBody body = return emptyC+isInjectiveHere nam idx clause = do+    let t    = patternToTerm idxR $ unArg $ clausePats clause !! idx+        t'   = substs (substForDot $ clausePats clause) t+        idxR = sum . map (nrBinds . unArg) . genericDrop (idx + 1) $ clausePats clause+        body = remAbs $ clauseBody clause+    body' <- lift $ reduce body+    injFs <- gets (injectiveFuns . importedModules)+    res <- (t' <: body') (M.insert nam (InjectiveFun (fromIntegral idx)+                                                     (genericLength (clausePats clause))) injFs)+    lift $ reportSDoc "epic.injection" 20 $ vcat+      [ text "isInjective:" <+> text (show nam)+      , text "at Index   :" <+> text (show idx)+      , nest 2 $ vcat+          [ text "clause     :" <+> text (show clause)+          , text "t          :" <+> prettyTCM t+          , text "idxR       :" <+> (text . show) idxR+          , text "body'      :" <+> (text . show) body'+          ]+      , text "res      :" <+> text (show res)+      ]+    return res++litToCon :: Literal -> TCM Term+litToCon l = case l of+    LitInt   r n | n > 0     -> do+        inner <- litToCon (LitInt r (n - 1))+        suc   <- primSuc+        return $ suc `apply` [defaultArg inner]+                 | otherwise -> primZero+--    LitLevel _ n -> -- Does not really matter+    lit          -> return $ Lit lit++litCon :: Literal -> Bool+litCon (LitInt _ _) = True+litCon _          = False++insertAt :: (Nat,Term) -> Term -> Term+insertAt (index, ins) = substs [if i == index then ins else Var i [] | i <- [0 .. ]]+++solve :: [QName] -> [((QName, InjectiveFun), [(QName,QName)])] -> Compile TCM [(QName, InjectiveFun)]+solve newNames xs = do+    -- Only primitive lists should be in the current module at this point,+    -- but we still want them+    conGraph <- M.union <$> gets (constrTags . curModule) <*> gets (constrTags . importedModules)+    (funs, mconstr) <- ($ xs) $ flip foldM ([] , Just $ initialTags conGraph newNames) $ \ (xs , prev) (fun , con) -> do+         m <- foldM solvable prev con+         return $ case m of+            Nothing -> (xs, prev)+            Just next -> (fun : xs, m)+    case mconstr of+        Nothing -> __IMPOSSIBLE__+        Just constr -> updateTags constr+    return funs+  where+    solvable :: Maybe Tags -> (QName, QName)+             -> Compile TCM (Maybe Tags)+    solvable Nothing _          = return Nothing+    solvable (Just st) (c1, c2) = unify c1 c2 st++    updateTags :: Tags -> Compile TCM ()+    updateTags tags = do+        let (hasTags, eqs) = M.partition isTag (constrGroup tags)+            isTag (IsTag _) = True+            isTag _         = False+        forM (M.toList hasTags) $ \ (c, tagged) -> case tagged of+            IsTag tag -> putCon c tag+            _         -> __IMPOSSIBLE__+        case M.toList eqs of+            (c, Same n) : _ -> do+                let grp = eqGroups tags !!! n+                tag <- assignConstrTag' c (S.toList grp)+                updateTags . fromMaybe __IMPOSSIBLE__ =<< setTag n tag tags { constrGroup = eqs }+            _              -> return ()+    putCon :: QName -> Tag -> Compile TCM ()+    putCon con tag = do+        m <- gets (constrTags . importedModules)+        case M.lookup con m of+            Nothing -> putConstrTag con tag+            Just _  -> return () -- old++emptyC :: InjConstraints+emptyC = Just []++addConstraint :: QName -> QName -> InjConstraints -> InjConstraints+addConstraint q1 q2 Nothing   = Nothing+addConstraint q1 q2 (Just xs) = Just (if q1 == q2 then xs else (q1,q2) : xs)++unionConstraints :: [InjConstraints] -> InjConstraints+unionConstraints [] = Just []+unionConstraints (Nothing : _) = Nothing+unionConstraints (Just c : cs) = do+    cs' <- unionConstraints cs+    return (c ++ cs')++-- | Are two terms injectible?+--   Precondition: t1 is normalised, t2 is in WHNF+-- When reducing t2, it may become a literal, which makes this not work in some cases...+(<:) :: Term -> Term -> (QName :-> InjectiveFun) -> Compile TCM InjConstraints+(Lit l        <:  t1)          injs | litCon l = do+    l' <- lift $ litToCon l+    (l' <: t1) injs+(t1 <: Lit l)                  injs | litCon l = do+    l' <- lift $ litToCon l+    (t1 <: l') injs+(t1           <: Def n2 args2) injs | Just (InjectiveFun argn arit) <- M.lookup n2 injs =+    if genericLength args2 /= arit+        then return Nothing+        else do+            arg <- lift $ reduce $ unArg $ args2 !! fromIntegral argn+            (t1 <: arg) injs+-- (Var n1 []    <: Var n2 [])    nam idx = return $ if n1 == n2 then emptyC else Nothing+(Var n1 args1 <: Var n2 args2) injs | n1 == n2 && length args1 == length args2 = do+    args1' <- map unArg <$> mapM (lift . reduce) args1+    args2' <- map unArg <$> mapM (lift . reduce) args2+    unionConstraints <$> zipWithM (\a b -> (a <: b) injs) args1' args2'+(Def q1 args1 <: Def q2 args2) injs | q1 == q2 && length args1 == length args2 = do+    args1' <- map unArg <$> mapM (lift . reduce) args1+    args2' <- map unArg <$> mapM (lift . reduce) args2+    unionConstraints <$> zipWithM (\a b -> (a <: b) injs) args1' args2'+(Con c1 args1 <: Con c2 args2) injs = do+    args1' <- map unArg <$> flip notForced args1 <$> getForcedArgs c1+    args2' <- map unArg <$> (mapM (lift . reduce) =<< flip notForced args2 <$> getForcedArgs c2)+    if length args1' == length args2'+        then addConstraint c1 c2 <$> unionConstraints <$> zipWithM (\a b -> (a <: b) injs) args1' args2'+        else return Nothing+(_            <: _) _ = return Nothing++data TagEq+    = Same Int+    | IsTag Tag+  deriving Eq++data Tags = Tags+    { eqGroups    :: Int :-> Set QName+    , constrGroup :: QName :-> TagEq+    }++initialTags :: Map QName Tag -> [QName] -> Tags+initialTags setTags newNames = Tags+    { eqGroups    = M.fromList $ zip [0..] (map S.singleton newNames)+    , constrGroup = M.map IsTag setTags `M.union` M.fromList (zip newNames (map Same [0..]))+    }++unify :: QName -> QName -> Tags -> Compile TCM (Maybe Tags)+unify c1 c2 ts = do+    let g1 = constrGroup ts !!! c1+        g2 = constrGroup ts !!! c2+    case (g1, g2) of+        (Same n1, Same n2)   | n1 == n2 -> return $ Just ts+        (IsTag t1, IsTag t2) | t1 == t2 -> return $ Just ts+        (Same n1, Same n2)   -> mergeGroups n1 n2 ts+        (Same n1, IsTag t2)  -> setTag n1 t2 ts+        (IsTag t1 , Same n2) -> setTag n2 t1 ts+        _                    -> return $ Nothing++setTag :: Int -> Tag -> Tags -> Compile TCM (Maybe Tags)+setTag gid tag ts = return $ Just $ ts+    { constrGroup = foldr (\c -> M.insert c (IsTag tag)) (constrGroup ts) (S.toList $ eqGroups ts !!! gid)}++mergeGroups :: Int -> Int -> Tags -> Compile TCM (Maybe Tags)+mergeGroups n1 n2 ts = do+    let g1s = eqGroups ts !!! n1+        g2s = eqGroups ts !!! n2+        gs  = S.union g1s g2s+    ifM (not . and <$> sequence [unifiable e1 e2 | e1 <- S.toList g1s, e2 <- S.toList g2s])+        (return Nothing) $+        return $ Just $ ts+            { eqGroups    = M.delete n2 $ M.insert n1 gs (eqGroups ts)+            , constrGroup = M.fromList [(e2, Same n1) | e2 <- S.toList g2s] `M.union` constrGroup ts+            }++unifiable :: QName -> QName -> Compile TCM Bool+unifiable c1 c2 = do+    d1 <- getConData c1+    d2 <- getConData c2+    return $ d1 /= d2++(!!!) :: Ord k => k :-> v -> k -> v+m !!!  k = case M.lookup k m of+    Nothing -> __IMPOSSIBLE__+    Just x  -> x

+ src/full/Agda/Compiler/Epic/Interface.hs view

@@ -0,0 +1,87 @@+{-# LANGUAGE DeriveDataTypeable #-}+-- | Epic interface data structure, which is serialisable and stored for each+--   compiled file+module Agda.Compiler.Epic.Interface where++import Control.Monad++import Data.Function+import qualified Data.Map as M+import Data.Map(Map)+import Data.Monoid+import qualified Data.Set as S+import Data.Set(Set)+import Data.Typeable++import Agda.Syntax.Common (Nat)+import Agda.Syntax.Internal++type Var       = String+data Tag       = Tag Int+               | PrimTag Var+  deriving (Show, Eq, Ord, Typeable)++data Forced = NotForced | Forced+  deriving (Show, Typeable, Eq)++-- | Filter a list using a list of Bools specifying what to keep.+pairwiseFilter :: [Bool] -> [a] -> [a]+pairwiseFilter (True :bs) (a:as) = a : pairwiseFilter bs as+pairwiseFilter (False:bs) (_:as) = pairwiseFilter bs as+pairwiseFilter _           _     = []++notForced :: ForcedArgs -> [a] -> [a]+notForced = pairwiseFilter . map (== NotForced)++forced :: ForcedArgs -> [a] -> [a]+forced = pairwiseFilter . map (== Forced)++data Relevance+  = Irr+  | Rel+  deriving (Eq, Ord, Show, Typeable)++type ForcedArgs   = [Forced]+type RelevantArgs = [Relevance]++data InjectiveFun = InjectiveFun+  { injArg     :: Nat+  , injArity   :: Nat+  }+  deriving (Show, Typeable, Eq)++data EInterface = EInterface+    { constrTags    :: Map QName Tag+    , definitions   :: Set Var+    , defDelayed    :: Map QName Bool+    , conArity      :: Map QName Int+    , mainName      :: Maybe QName+    , relevantArgs  :: Map Var   RelevantArgs+    , forcedArgs    :: Map QName ForcedArgs+    , injectiveFuns :: Map QName InjectiveFun+    } deriving (Typeable, Show)++instance Monoid EInterface where+  mempty = EInterface+      { constrTags    = mempty+      , definitions   = mempty+      , defDelayed    = mempty+      , conArity      = mempty+      , mainName      = Nothing+      , relevantArgs  = mempty+      , forcedArgs    = mempty+      , injectiveFuns = mempty+      }+  mappend x y = EInterface+      { constrTags    = comb constrTags+      , definitions   = comb definitions+      , defDelayed    = comb defDelayed+      , conArity      = comb conArity+      , mainName      = mainName x `mplus` mainName y+      , relevantArgs  = comb relevantArgs+      , forcedArgs    = comb forcedArgs+      , injectiveFuns = comb injectiveFuns+      }+    where+      comb :: Monoid a => (EInterface -> a) -> a+      comb f = (mappend `on` f) x y

− src/full/Agda/Compiler/Epic/LambdaLift.hs

@@ -1,60 +0,0 @@--- | Lift lambda expressions to top level definitions (Epic does not support---   lambdas).-module Agda.Compiler.Epic.LambdaLift where--import Control.Applicative-import Control.Monad.Trans-import Control.Monad.Writer-import qualified Data.Set as S--import Agda.Compiler.Epic.AuxAST-import Agda.Compiler.Epic.CompileState--import Agda.TypeChecking.Monad.Base (MonadTCM)---- | LL makes it possible to emit new functions when we encounter a lambda-type LL = WriterT [Fun]---- | lambda lift all the functions-lambdaLift :: MonadTCM m => [Fun] -> Compile m [Fun]-lambdaLift fs = do-  concat <$> sequence-    [do (f', lifts) <- runWriterT (lambdaLiftFun f)-        return $ f' : lifts-    | f <- fs]---- | λ lift a function, this is in a LL (Writer monad)-lambdaLiftFun :: MonadTCM m => Fun -> LL (Compile m) Fun-lambdaLiftFun (Fun i name c vs e) = Fun i name c vs <$> lambdaLiftExpr e-lambdaLiftFun f@(EpicFun _ _ _)   = return f---- | λ lift an expression, put all the new definitions in the writer monad-lambdaLiftExpr :: MonadTCM m => Expr -> LL (Compile m) Expr-lambdaLiftExpr expr = case expr of-    Var _    -> return expr-    Lit _    -> return expr-    e1@(Lam _ _) -> do-      -- This is the only difficult case, get a group of lambda binders,-      -- lambda lift the body of it, and create a new supercombinator from-      -- this.-      let (vs, e2) = collectLam e1-      topBinding <- lift topBindings-      let vs' = filter (`S.notMember` topBinding) $ fv e1-      e3 <- lambdaLiftExpr e2-      name <- lift newName-      tell [Fun True name "lambda" (vs' ++ vs) e3]-      return $ apps name (map Var vs')-    Con c n es -> Con c n <$> mapM lambdaLiftExpr es-    App v es -> App v <$> mapM lambdaLiftExpr es-    Case e brs -> Case <$> lambdaLiftExpr e-                       <*> mapM (\br -> do lle <- lambdaLiftExpr $ brExpr br; return br {brExpr = lle}) brs-    If a b c   -> If <$> lambdaLiftExpr a <*> lambdaLiftExpr b <*> lambdaLiftExpr c-    Let v e e' -> Let v <$> lambdaLiftExpr e <*> lambdaLiftExpr e'-    Lazy e     -> Lazy <$> lambdaLiftExpr e-    UNIT       -> return UNIT-    IMPOSSIBLE -> return IMPOSSIBLE-  where-    -- | Collect all the variables in a group of lambdas-    collectLam :: Expr -> ([Var], Expr)-    collectLam (Lam v e) = let (vs, e') = collectLam e in (v:vs, e')-    collectLam e         = ([], e)

src/full/Agda/Compiler/Epic/NatDetection.hs view

@@ -1,3 +1,4 @@+{-# LANGUAGE CPP #-} -- | Detect if a datatype could be represented as a primitive integer. --   If it has one constructor with no arguments and one with a recursive --   argument this is true. This is done using IrrFilters which filter out@@ -14,49 +15,61 @@  import Agda.TypeChecking.Monad import Agda.Syntax.Internal+import Agda.TypeChecking.Substitute import Agda.Syntax.Common -import Agda.Compiler.Epic.CompileState hiding (conPars)+import Agda.Compiler.Epic.CompileState+import Agda.Compiler.Epic.Interface +#include "../../undefined.h"+import Agda.Utils.Impossible+ -- | Get a list of all the datatypes that look like nats. The [QName] is on the --   form [zeroConstr, sucConstr]-getNatish :: MonadTCM m => Compile m [(IrrFilter,[QName])]+getNatish :: Compile TCM [(ForcedArgs, [QName])] getNatish = do   sig <- lift (gets (sigDefinitions . stImports))   let defs = M.toList sig   fmap catMaybes $ forM defs $ \(q, def) ->     case theDef def of-      d@(Datatype {}) -> do -- A datatype ...-          case dataCons d of-              constrs | length constrs == 2 -> do -- with two constructors ...-                  z <- zip constrs <$> mapM getIrrFilter constrs-                  case sortBy (compare `on` nrRel . snd) z of-                    [(cz,fz), (cs,fs)] -> do-                      let ts = defType $ sig M.! cs-                          nr = fromIntegral $ dataPars d-                      return $ do-                       guard (nrRel fz == 0) -- where one constructor has zero arguments ...-                       guard (nrRel fs == 1) -- and the other one one argument ...-                       guard (isRec ((fromJust $ elemIndex True fs) + nr) ts q) -- which is recursive.-                       return (fs, [cz, cs]) -- It's natish!-                    _ -> return Nothing-              _       -> return Nothing+      d@(Datatype {}) -> isNatish q d+       _ -> return Nothing +isNatish :: QName -> Defn -> Compile TCM (Maybe (ForcedArgs, [QName]))+isNatish q d = do -- A datatype ...+    case dataCons d of+        constrs | length constrs == 2 -> do -- with two constructors ...+            b <- and <$> mapM constrInScope constrs+            if b+              then do+                z <- zip constrs <$> mapM getForcedArgs constrs+                case sortBy (compare `on` nrRel . snd) z of+                  [(cz,fz), (cs,fs)] -> do+                    sig <- lift (gets (sigDefinitions . stImports))+                    let ts = defType $ sig M.! cs+                        nr = fromIntegral $ dataPars d+                    return $ do+                     guard (nrRel fz == 0) -- where one constructor has zero arguments ...+                     guard (nrRel fs == 1) -- and the other one one argument ...+                     guard (isRec ((fromMaybe __IMPOSSIBLE__ $ elemIndex NotForced fs) + nr) ts q) -- which is recursive.+                     return (fs, [cz, cs]) -- It's natish!+                  _ -> return Nothing+              else return Nothing+        _       -> return Nothing+ -- | Count the number of relevant arguments-nrRel :: IrrFilter -> Integer-nrRel = sum . map (const 1) . filter id+nrRel :: ForcedArgs -> Integer+nrRel = sum . map (const 1) . filter (== NotForced)  -- | Check if argument n is recursive isRec :: Int -> Type -> QName -> Bool isRec 0 (El _ t) dat = case t of-    Fun arg _ -> argIsDef (unArg arg) dat     Pi  arg _ -> argIsDef (unArg arg) dat-    _       -> False+    _         -> False isRec n (El _ t) dat = case t of-    Pi  _ ab  -> isRec (n - 1) (absBody ab) dat-    Fun _ typ -> isRec (n - 1) typ           dat-    _           -> False+    Pi  _ ab  -> isRec (n - 1) (unAbs ab) dat+    _         -> False  argIsDef :: Type -> QName -> Bool argIsDef (El _ t) dat = case t of

src/full/Agda/Compiler/Epic/Primitive.hs view

@@ -18,6 +18,7 @@  import Agda.Compiler.Epic.AuxAST import Agda.Compiler.Epic.CompileState+import Agda.Compiler.Epic.Interface import Agda.Compiler.Epic.NatDetection  #include "../../undefined.h"@@ -30,87 +31,96 @@   , translateCase :: Expr -> [Branch] -> Expr   } +prZero, prSuc, prTrue, prFalse, prPred, prNatEquality :: Var+prZero  = "primZero"+prSuc   = "primSuc"+prTrue  = "primTrue"+prFalse = "primFalse"+prPred  = "primPred"+prNatEquality = "primNatEquality"+ -- | Change constructors and cases on builtins and natish datatypes to use --   primitive data-primitivise :: MonadTCM m => [Fun] -> Compile m [Fun]+primitivise :: [Fun] -> Compile TCM [Fun] primitivise funs = do     ptfs   <- getBuiltins     natish <- getNatish-    lists  <- primLists-    (++ lists) <$> mapM (primFun $ ptfs ++ map (uncurry natPrimTF) natish) funs+    mapM (primFun $ ptfs ++ map (uncurry natPrimTF) natish) funs --- | Create primitive functions if list constructors are marked as builtins-primLists :: MonadTCM m => Compile m [Fun]-primLists = do-    mnil  <- lift $ getBuiltin' builtinNil-    mcons <- lift $ getBuiltin' builtinCons-    case (mnil, mcons) of-      (Just (T.Con nil []), Just (T.Con cons [])) -> do-          [nilT, consT] <- mapM getConstrTag [nil, cons]-          let fun s n = Fun-                   { funInline  = True-                   , funName    = "prim" ++ s-                   , funComment = "BUILTIN " ++ s-                   , funArgs    = []-                   , funExpr    = Var (unqname n)-                   }-          return [ fun "Nil" nil-                 , fun "Cons" cons-                 , Fun-                    { funInline  = False-                    , funName    = "primListElim"-                    , funComment = "Eliminator for Lists"-                    , funArgs    = ["op" , "z" , "xs"]-                    , funExpr    = Case (Var "xs")-                        [ Branch nilT nil [] $ Var "z"-                        , Branch consT cons ["y", "ys"] $-                            App "op" [ Var "y"-                                     , App "primListElim" [ Var "op"-                                                          , Var "z"-                                                          , Var "ys"-                                                          ]-                                     ]-                        ]-                    }-                 ]-      _                     -> return []+-- | Map primitive constructors to primitive tags+initialPrims :: Compile TCM () -- [Fun]+initialPrims = do+  -- TODO: Natishness is calculated here and could be stored so it does not have+  --       to be recalculated in primitivise+  natish <- getNatish+  -- This has to be done because injection detection may otherwise flag injections+  -- between non-primitive and primitive datatypes in the wrong way+  sequence_ [zipWithM_ putConstrTag [zc, sc] (prim [prZero, prSuc])+            | (_, [zc, sc]) <- natish]+  sequence_+    [ [builtinNil, builtinCons]           ~> tags [0, 1]+    , [builtinZero, builtinSuc  ]         ~> prim [prZero, prSuc]+    , [builtinLevelZero, builtinLevelSuc] ~> prim [prZero, prSuc]+    , [builtinTrue, builtinFalse]         ~> prim [prTrue, prFalse]+    , [builtinRefl]                       ~> tags [0]+    ]+  where+    prim = map PrimTag+    tags = map Tag+    constrs ~> tags = do+        builtins  <- lift $ mapM getBuiltin' constrs+        if all isJust builtins+           then do+                let names = map (defName . fromMaybe __IMPOSSIBLE__) builtins+                -- b <- and <$>  mapM constrInScope names+                -- if b then return $ Just (transf names) else return Nothing+                zipWithM_ putConstrTag names tags+           else return ()+ -- | Build transforms using the names of builtins-getBuiltins :: MonadTCM m => Compile m [PrimTransform]+getBuiltins :: Compile TCM [PrimTransform] getBuiltins =     catMaybes <$> sequence-      [ [builtinZero, builtinSuc  ]         ~> natPrimTF [True]-       -- ? is this ok to have [True]-      , [builtinLevelZero, builtinLevelSuc] ~> natPrimTF [True]+      [ [builtinZero, builtinSuc  ]         ~> natPrimTF [NotForced]+       -- ? is this ok to have [NotForced]+      , [builtinLevelZero, builtinLevelSuc] ~> natPrimTF [NotForced]       , [builtinTrue, builtinFalse]         ~> boolPrimTF       ]   where     constrs ~> transf = do-        builtins <- lift $ mapM getBuiltin' constrs+        builtins  <- lift $ mapM getBuiltin' constrs         if all isJust builtins-           then return $ Just (transf (map (defName . fromMaybe __IMPOSSIBLE__) builtins))+           then do+                let names = map (defName . fromMaybe __IMPOSSIBLE__) builtins+                b <- and <$>  mapM constrInScope names+                if b then return $ Just (transf names) else return Nothing            else return Nothing-    defName (T.Def q []) = q-    defName (T.Con q []) = q-    defName _            = __IMPOSSIBLE__ +defName (T.Def q []) = q+defName (T.Con q []) = q+defName _            = __IMPOSSIBLE__++head'' (x:xs) e = x+head'' _      e = e+ -- | Translation to primitive integer functions-natPrimTF :: IrrFilter -> [QName] -> PrimTransform+natPrimTF :: ForcedArgs -> [QName] -> PrimTransform natPrimTF filt [zero, suc] = PrimTF-  { mapCon = M.fromList [(zero, "primZero"), (suc, "primSuc")]+  { mapCon = M.fromList [(zero, prZero), (suc, prSuc)]   , translateCase = \ce brs -> case brs of         -- Assuming only the first two branches are relevant when casing on Nats-        (Branch _ n vs e:Branch _ _n' vs' e':_) ->+        (Branch _ n vs e:Branch _ _n' vs'' e'':_) ->             if n == zero-               then primNatCaseZS ce e  (head (pairwiseFilter filt vs')) e'-               else primNatCaseZS ce e' (head (pairwiseFilter filt vs )) e-        (Branch _ n vs e:Default e':_) ->+               then primNatCaseZS ce e  (head'' vs'' __IMPOSSIBLE__) e''+               else primNatCaseZS ce e'' (head'' vs __IMPOSSIBLE__) e+        (Branch _ n vs e:Default e'':_) ->             if n == zero-               then primNatCaseZD ce e e' -- zero-               else primNatCaseZS ce e' (head (pairwiseFilter filt vs )) e -- suc+               then primNatCaseZD ce e e'' -- zero+               else primNatCaseZS ce e'' (head'' vs __IMPOSSIBLE__) e -- suc         [ Branch _ n vs e ] ->             if n == zero               then e-              else Let (head (pairwiseFilter filt vs)) (App "primPred" [ce]) e+              else lett (head'' vs __IMPOSSIBLE__) (App prPred [ce]) e         _ -> __IMPOSSIBLE__   } natPrimTF _ _ = __IMPOSSIBLE__@@ -122,19 +132,19 @@               -> Expr -- ^ Expression used for suc branch               -> Expr -- ^ Result? primNatCaseZS n zeroBr v sucBr =-    If (App "primNatEquality" [n, Var "primZero"]) zeroBr (Let v (App "primPred" [n]) sucBr)+    If (App prNatEquality [n, Var prZero]) zeroBr (lett v (App prPred [n]) sucBr)  -- | Corresponds to a case with a zero and default branch primNatCaseZD :: Expr -- ^ Expression that is cased on               -> Expr -- ^ Zero branch               -> Expr -- ^ Default branch               -> Expr -- ^ Result?-primNatCaseZD n zeroBr defBr = If (App "primNatEquality" [n, Var "primZero"]) zeroBr defBr+primNatCaseZD n zeroBr defBr = If (App prNatEquality [n, Var prZero]) zeroBr defBr  -- | Translation to primitive bool functions boolPrimTF :: [QName] -> PrimTransform boolPrimTF [true, false] = PrimTF-  { mapCon = M.fromList [(true, "primTrue"), (false, "primFalse")]+  { mapCon = M.fromList [(true, prTrue), (false, prFalse)]   , translateCase = \ce brs ->     case brs of         (Branch _ n _vs e:b':_) ->@@ -146,22 +156,22 @@ boolPrimTF _ = __IMPOSSIBLE__  -- | Change all the primitives in the function using the PrimTransform-primFun :: MonadTCM m => [PrimTransform] -> Fun -> Compile m Fun-primFun ptfs (Fun i n c args e) =-    Fun i n c args <$> primExpr ptfs e+primFun :: [PrimTransform] -> Fun -> Compile TCM Fun+primFun ptfs (Fun i n qn c args e) =+    Fun i n qn c args <$> primExpr ptfs e primFun _ e@(EpicFun {}) = return e   -- | Change all the primitives in an expression using PrimTransform-primExpr :: MonadTCM m => [PrimTransform] -> Expr -> Compile m Expr+primExpr :: [PrimTransform] -> Expr -> Compile TCM Expr primExpr prim ex = case ex of     Var{}    -> return ex     Lit{}    -> return ex     Lam v e1 -> Lam v <$> primExpr prim e1     Con c n es -> case testCon prim n of         Just pn -> do-            filt <- getIrrFilter n-            apps pn <$> mapM (primExpr prim) (pairwiseFilter filt es)+            filt <- getForcedArgs n+            apps pn <$> mapM (primExpr prim) es         Nothing -> Con c n <$> mapM (primExpr prim) es     App v es   -> App v <$> mapM (primExpr prim) es     Case e brs -> case testBranch prim brs of@@ -195,7 +205,7 @@         Default _       -> Nothing      -- | Change all primitives in a branch-    primBranch :: MonadTCM m => Branch -> Compile m Branch+    primBranch :: Branch -> Compile TCM Branch     primBranch br = do         e' <- primExpr prim (brExpr br)         return br {brExpr = e'}

+ src/full/Agda/Compiler/Epic/Smashing.hs view

@@ -0,0 +1,135 @@+{-# LANGUAGE CPP #-}+-- | Smash functions which return something that can be inferred+--   (something of a type with only one element)++module Agda.Compiler.Epic.Smashing where++import Control.Arrow((&&&))+import Control.Monad+import Control.Monad.State+import Control.Monad.Trans++import Data.List+import qualified Data.Map as M+import Data.Map (Map)+import Data.Maybe++import qualified Data.Set as S+import Data.Set (Set)++import Agda.Syntax.Common+import Agda.Syntax.Internal as SI+import Agda.TypeChecking.Monad+import Agda.TypeChecking.Substitute+import Agda.TypeChecking.Telescope+import Agda.TypeChecking.Pretty+import Agda.TypeChecking.Reduce+import Agda.TypeChecking.Rules.LHS.Unify++import Agda.Compiler.Epic.AuxAST as AA+import Agda.Compiler.Epic.CompileState+import Agda.Compiler.Epic.Interface++import Agda.Utils.Monad+import Agda.Utils.Size++#include "../../undefined.h"+import Agda.Utils.Impossible++defnPars :: Integral n => Defn -> n+defnPars (Record      {recPars = p}) = fromIntegral p+defnPars (Constructor {conPars = p}) = fromIntegral p+defnPars d                           = 0++-- | Main function, smash as much as possible+smash'em :: [Fun] -> Compile TCM [Fun]+smash'em funs = do+    defs <- lift (gets (sigDefinitions . stImports))+    funs' <- forM funs $ \f -> case f of+      AA.Fun{} -> case funQName f >>= flip M.lookup defs of+          Nothing -> do+              lift $ reportSDoc "epic.smashing" 10 $ vcat+                [ (text . show) f <+> text " was not found"]+              return f++          Just def -> do+              lift $ reportSLn "epic.smashing" 10 $ "running on:" ++ (show (funQName f))+              minfered <- smashable (length (funArgs f) + defnPars (theDef def)) (defType def)+              case minfered of+                  Just infered -> do+                      lift $ reportSDoc "smashing" 5 $ vcat+                        [ prettyTCM (defName def) <+> text "is smashable"]+                      return f { funExpr = infered+                               , funInline = True+                               , funComment = funComment f ++ " [SMASHED]"+                               }+                  Nothing -> return f+      _ -> do+        lift $ reportSLn "epic.smashing" 10 $ "smashing!"+        return f+    return funs'++(+++) :: Telescope -> Telescope -> Telescope+xs +++ ys = unflattenTel names $ map (raise (size ys)) (flattenTel xs) ++ flattenTel ys+  where names = teleNames xs ++ teleNames ys++-- | Can a datatype be inferred? If so, return the only possible value.+inferable :: Set QName -> QName -> [Arg Term] ->  Compile TCM (Maybe Expr)+inferable visited dat args | dat `S.member` visited = return Nothing+inferable visited dat args = do+  lift $ reportSLn "epic.smashing" 10 $ "  inferring:" ++ (show dat)+  defs <- lift (gets (sigDefinitions . stImports))+  let def = fromMaybe __IMPOSSIBLE__ $ M.lookup dat defs+  case theDef def of+      d@Datatype{} -> do+          case dataCons d of+            [c] -> inferableArgs c (dataPars d)+            _   -> return Nothing+      r@Record{}   -> inferableArgs (recCon r) (recPars r)+      f@Function{} -> do+        term <- lift $ normalise $ Def dat args+        inferableTerm visited' term+      d -> do+        lift $ reportSLn "epic.smashing" 10 $ "  failed (inferable): " ++ (show d)+        return Nothing+  where+    inferableArgs c pars = do+        defs <- lift (gets (sigDefinitions . stImports))+        let def = fromMaybe __IMPOSSIBLE__ $ M.lookup c defs+        forc <- getForcedArgs c+        TelV tel _ <- lift $ telView (defType def `apply` genericTake pars args)+        tag <- getConstrTag c+        lift $ reportSDoc "epic.smashing" 10 $ nest 2 $ vcat+          [ text "inferableArgs!"+          , text "tele" <+> prettyTCM tel+          , text "constr:" <+> prettyTCM c+          ]+        (AA.Con tag c <$>) <$> sequence <$> forM (notForced forc $ flattenTel tel) (inferableTerm visited' . unEl . unArg)+    visited' = S.insert dat visited++inferableTerm visited t = case t of+    Def q as     -> inferable visited q as+    Pi _   b    -> (AA.Lam "_" <$>) <$> inferableTerm visited (unEl $ unAbs b)+    Sort {}     -> return . return $ AA.UNIT+    t           -> do+      lift $ reportSLn "epic.smashing" 10 $ "  failed to infer: " ++ show t+      return Nothing++-- | Find the only possible value for a certain type. If we fail return Nothing+smashable :: Int -> Type -> Compile TCM (Maybe Expr)+smashable origArity typ = do+    defs <- lift (gets (sigDefinitions . stImports))+    TelV tele retType <- lift $ telView typ+    retType' <- return retType -- lift $ reduce retType++    inf <- inferableTerm S.empty (unEl retType')+    lift $ reportSDoc "epic.smashing" 10 $ nest 2 $ vcat+      [ text "Result is"+      , text "inf: " <+> (text . show) inf+      , text "type: " <+> prettyTCM retType'+      ]+    return $ buildLambda (size tele - origArity) <$> inf++buildLambda :: (Ord n, Num n) => n -> Expr -> Expr+buildLambda n e | n <= 0    = e+buildLambda n e | otherwise = AA.Lam "_" (buildLambda (n - 1) e)

+ src/full/Agda/Compiler/Epic/Static.hs view

@@ -0,0 +1,101 @@+-- | Find the places where the builtin static is used and do some normalisation+--   there.++{-# LANGUAGE CPP #-}++module Agda.Compiler.Epic.Static where++import Control.Applicative+import Control.Monad+import Control.Monad.State+import Control.Monad.Trans++import qualified Data.Map as M++import Agda.Syntax.Common+import Agda.Syntax.Internal++import Agda.TypeChecking.CompiledClause+import Agda.TypeChecking.Monad.Base+import Agda.TypeChecking.Monad.Builtin+import Agda.TypeChecking.Monad.Options+import Agda.TypeChecking.Reduce+import Agda.TypeChecking.Substitute+import Agda.TypeChecking.Pretty++import Agda.Utils.Monad++import Agda.Compiler.Epic.CompileState++#include "../../undefined.h"+import Agda.Utils.Impossible++normaliseStatic :: CompiledClauses -> Compile TCM CompiledClauses+normaliseStatic = evaluateCC++evaluateCC :: CompiledClauses -> Compile TCM CompiledClauses+evaluateCC ccs = case ccs of+    Case n brs -> do+        cbrs <- forM (M.toList $ conBranches brs) $ \(c, cc) -> (,) c <$> evaluateCC cc+        lbrs <- forM (M.toList $ litBranches brs) $ \(l, cc) -> (,) l <$> evaluateCC cc+        cab <- case catchAllBranch brs of+            Nothing -> return Nothing+            Just cc -> Just <$> evaluateCC cc+        return $ Case n Branches+            { conBranches    = M.fromList cbrs+            , litBranches    = M.fromList lbrs+            , catchAllBranch = cab+            }+    Done n t   -> Done n <$> evaluateTerm t+    Fail       -> return Fail++etaExpand :: Term -> Compile TCM Term+etaExpand def@(Def n ts) = do+    defs <- lift (gets (sigDefinitions . stImports))+    let f   = maybe __IMPOSSIBLE__ theDef (M.lookup n defs)+        len = length . clausePats . head .  funClauses $ f+        toEta :: Num a => a+        toEta = fromIntegral $ len - length ts+        term  = raise toEta def `apply` [ defaultArg $ Var i [] | i <- [toEta - 1, toEta - 2 .. 0]]+    return $ foldr (\ v t -> Lam NotHidden (Abs v t)) term $ replicate toEta "staticVar"+etaExpand x = return x++evaluateTerm :: Term -> Compile TCM Term+evaluateTerm term = case term of+    Var x as     -> Var x <$>  evaluateTerms as+    Lam h ab     -> do+      ab' <- evaluateTerm (unAbs ab)+      return $ Lam h $ Abs (absName ab) ab'+    Lit l        -> return $ Lit l+    Def n ts -> do+        ifM (not <$> isStatic n)+            (Def n <$> evaluateTerms ts) $ do+                feta <- return term -- etaExpand term+                f <- lift $ normalise feta+                lift $ reportSDoc "epic.static" 10 $ vcat+                  [ text "STATIC pragma fired"+                  , nest 2 $ vcat+                    [ text "before :" <+> prettyTCM term+                    , text "after  :" <+> prettyTCM f+                    ]+                  ]+                return f+    Con c args   -> Con c <$> evaluateTerms args+    Pi  arg abs  -> return $ Pi  arg abs+    Sort s       -> return $ Sort s+    MetaV i args -> return $ MetaV i args+    Level l      -> return $ Level l+    DontCare i   -> return $ DontCare i+  where+    evaluateTerms :: Args -> Compile TCM Args+    evaluateTerms as = forM as $ \x -> do+      y <- evaluateTerm (unArg x)+      return x { unArg = y }++    isStatic :: QName -> Compile TCM Bool+    isStatic q = do+      defs <- lift (gets (sigDefinitions . stImports))+      return $ case fmap theDef $ M.lookup q defs of+          Nothing -> False+          Just (f@Function{}) -> funStatic f+          Just _              -> False

src/full/Agda/Compiler/HaskellTypes.hs view

@@ -33,6 +33,9 @@ hsFun :: HaskellKind -> HaskellKind -> HaskellKind hsFun a b = "(" ++ a ++ " -> " ++ b ++ ")" +hsUnit :: HaskellType+hsUnit = "()"+ hsVar :: Name -> HaskellType hsVar x = "x" ++ concatMap encode (show x)   where@@ -50,40 +53,44 @@ hsForall :: String -> HaskellType -> HaskellType hsForall x a = "(forall " ++ x ++ ". " ++ a ++ ")" -notAHaskellKind :: MonadTCM tcm => Type -> tcm a+notAHaskellKind :: Type -> TCM a notAHaskellKind a = do   err <- fsep $ pwords "The type" ++ [prettyTCM a] ++                 pwords "cannot be translated to a Haskell kind."   typeError $ GenericError $ show err -notAHaskellType :: MonadTCM tcm => Type -> tcm a+notAHaskellType :: Type -> TCM a notAHaskellType a = do   err <- fsep $ pwords "The type" ++ [prettyTCM a] ++                 pwords "cannot be translated to a Haskell type."   typeError $ GenericError $ show err -getHsType :: MonadTCM tcm => QName -> tcm HaskellType+getHsType :: QName -> TCM HaskellType getHsType x = do-  d <- theDef <$> getConstInfo x+  d <- compiledHaskell . defCompiledRep <$> getConstInfo x   case d of-    Axiom{ axHsDef = Just (HsType t) } -> return t-    Datatype{ dataHsType = Just t }    -> return t-    _                                  -> notAHaskellType (El Prop $ Def x [])+    Just (HsType t)   -> return t+    Just (HsDefn t c) -> return hsUnit+    _                 -> notAHaskellType (El Prop $ Def x []) -getHsVar :: MonadTCM tcm => Nat -> tcm HaskellCode+getHsVar :: Nat -> TCM HaskellCode getHsVar i = hsVar <$> nameOfBV i  isHaskellKind :: Type -> TCM Bool isHaskellKind a =   (const True <$> haskellKind a) `catchError` \_ -> return False -haskellKind :: MonadTCM tcm => Type -> tcm HaskellKind+haskellKind :: Type -> TCM HaskellKind haskellKind a = do   a <- reduce a   case unEl a of     Sort _  -> return hsStar     Pi a b  -> hsKFun <$> haskellKind (unArg a) <*> underAbstraction a b haskellKind-    Fun a b -> hsKFun <$> haskellKind (unArg a) <*> haskellKind b+    Def d _ -> do+      d <- compiledHaskell . defCompiledRep <$> getConstInfo d+      case d of+        Just (HsType t) -> return hsStar+        _               -> notAHaskellKind a     _       -> notAHaskellKind a  -- | Note that @Inf a b@, where @Inf@ is the INFINITY builtin, is@@ -93,13 +100,14 @@ -- Note that if @haskellType@ supported universe polymorphism then the -- special treatment of INFINITY might not be needed. -haskellType :: MonadTCM tcm => Type -> tcm HaskellType+haskellType :: Type -> TCM HaskellType haskellType = liftTCM . fromType   where     fromArgs = mapM (fromTerm . unArg)     fromType = fromTerm . unEl     fromTerm v = do       v   <- reduce v+      reportSLn "compile.haskell.type" 50 $ "toHaskellType " ++ show v       kit <- liftTCM coinductionKit       let err = notAHaskellType (El Prop v)       case v of@@ -109,21 +117,16 @@             [a, b] -> fromTerm (unArg b)             _      -> err         Def d args -> hsApp <$> getHsType d <*> fromArgs args-        Fun a b    -> hsFun <$> fromType (unArg a) <*> fromType b         Pi a b ->-          ifM (isHaskellKind $ unArg a)-          (underAbstraction a b $ \b -> do-              x <- getHsVar 0-              b <- fromType b-              return $ hsForall x $ hsFun "()" b-          )-          (if 0 `freeIn` absBody b-           then err-           else hsFun <$> fromType (unArg a) <*> fromType (absApp b __IMPOSSIBLE__)-          )-        Con{}      -> err+          if isBinderUsed b+          then underAbstraction a b $ \b ->+            hsForall <$> getHsVar 0 <*>+              (hsFun <$> fromType (unArg a) <*> fromType b)+          else hsFun <$> fromType (unArg a) <*> fromType (absApp b __IMPOSSIBLE__)+        Con c args -> hsApp <$> getHsType c <*> fromArgs args         Lam{}      -> err-        Lit{}      -> err-        Sort{}     -> err+        Level{}    -> return hsUnit+        Lit{}      -> return hsUnit+        Sort{}     -> return hsUnit         MetaV{}    -> err-        DontCare   -> err+        DontCare{} -> err

+ src/full/Agda/Compiler/JS/Case.hs view

@@ -0,0 +1,127 @@+{-# LANGUAGE CPP #-}++module Agda.Compiler.JS.Case where++import Prelude hiding ( null )+import Data.Map ( Map, empty, null, mapWithKey, fromListWith, unionWith )+import Data.List ( genericLength, genericTake, intercalate )++import Agda.Syntax.Common ( Nat )+import Agda.Utils.Impossible ( Impossible(Impossible), throwImpossible )++import Agda.Compiler.JS.Pretty ( Pretty, pretty, pretties )+import Agda.Compiler.JS.Syntax+  ( Exp(Undefined,Local,Lambda,Object,Apply,Lookup),+    LocalId(LocalId), MemberId )+import Agda.Compiler.JS.Substitution ( shiftFrom )++#include "../../undefined.h"++-- ECMAScript doesn't support pattern-mathching case, so+-- we translate to a visitor pattern.  We use a decision-tree+-- translation, as that seems to fit visitor objects better.++data Case = Case { pats :: [Patt], body :: Exp }+  deriving (Show)++instance Pretty Case where+  pretty n i (Case ps e) =+    intercalate " " (pretties n i ps) ++ " -> " ++ pretty (n + numVars ps) i e++-- Not handling literal patterns yet+-- Note that all patterns introduce binders, in depth-first prefix order,+-- for example Tagged l [ VarPatt , VarPatt ] should be thought+-- of as "x2 @ l (x1, x0)".++data Patt =+  VarPatt |+  Tagged Tag [Patt]+  deriving (Show)++instance Pretty Patt where+  pretty n i VarPatt = "x"+  pretty n i (Tagged (Tag l _ _) ps) =+    "(" ++ intercalate " " (pretty n i l : pretties n i ps) ++ ")"++-- With each tag, we record its name, and the names of the+-- other constructors of the datatype (e.g. we'd represent+-- zero as Tag "zero" ["suc","zero"]).  We also record the+-- the function which accepts a visitor (by default Apply,+-- but can be over-ridden by the FFI).++data Tag = Tag MemberId [MemberId] (Exp -> [Exp] ->  Exp)++instance Show Tag where+  show (Tag i is _) = show i++-- Number of bound variables in a pattern++numVars :: [Patt] -> Nat+numVars = sum . map numVars'++numVars' :: Patt -> Nat+numVars' (VarPatt)     = 1+numVars' (Tagged l ps) = 1 + numVars ps++-- Compile a case statement to a function+-- in lambda n cs, n is the number of parameters++lambda :: [Case] -> Exp+lambda []     = Undefined+lambda (c:cs) = lambda' 0 0 (genericLength (pats c)) (c:cs)++-- In lambda' l m n cs,+-- l is the number of free variables,+-- m is the number of already read parameters, with m <= l, and+-- n is the number of unread parameters.+-- Each case should be of the form (Case ps e) where ps has length m+n.+-- e can have (l - m + #bv ps) variables free.+-- lambda' l m n cs can have l variables free.++lambda' :: Nat -> Nat -> Nat -> [Case] -> Exp+lambda' l m n []       = Undefined+lambda' l 0 0 (c : cs) = body c+lambda' l 0 n cs       = Lambda 1 (lambda' (l+1) 1 (n-1) cs)+lambda' l m n cs       =+  case null ts of+    True -> lambda' l (m-1) n (map pop cs)+    False -> visit cs (Local (LocalId (m-1))) [Object (mapWithKey (match l (m-1) n cs) ts)]+  where+    ts = tags cs++-- Pop cases++pop :: Case -> Case+pop (Case (VarPatt : ps) e) = (Case ps e)+pop _                       = __IMPOSSIBLE__++-- Cases which match a given tag/arity++match :: Nat -> Nat -> Nat -> [Case] -> MemberId -> Nat -> Exp+match l m n cs t x = Lambda x (lambda' (l + x) (m + x) n (concat (map (refine t x) cs)))++-- Refine a case statement by a given tag/arity++refine :: MemberId -> Nat -> Case -> [Case]+refine t x (Case (VarPatt : qs) e) =+  [Case (genericTake x (repeat VarPatt) ++ qs) (shiftFrom (numVars qs) x e)]+refine t x (Case (Tagged (Tag u _ _) ps : qs) e) | t == u =+  [Case (ps ++ qs) e]+refine _ _ _ = []++-- Extract the visit function++visit :: [Case] -> Exp -> [Exp] -> Exp+visit (Case (Tagged (Tag _ _ v) _ : _) _ : _ ) = v+visit (Case (VarPatt              : _) _ : cs) = visit cs+visit _                                        = Apply++-- Extract the list of possible tags, and their arity.++tags :: [Case] -> Map MemberId Nat+tags = foldl (unionWith max) empty . map tag++tag :: Case -> Map MemberId Nat+tag (Case (Tagged (Tag t us _) ps : qs) e) =+  fromListWith max ((t, genericLength ps) : [ (u, 0) | u <- us ])+tag _ = empty

+ src/full/Agda/Compiler/JS/Compiler.hs view

@@ -0,0 +1,448 @@+{-# LANGUAGE CPP #-}++module Agda.Compiler.JS.Compiler where++import Prelude hiding ( null, writeFile )+import Control.Monad.Reader ( liftIO )+import Control.Monad.State ( get, put )+import Data.List ( intercalate, map, filter, isPrefixOf, concat, genericDrop, genericLength )+import Data.Set ( Set, empty, null, insert, difference, delete )+import Data.Map ( Map, fold, singleton, fromList, toList, toAscList, insertWith, elems )+import System.Directory ( createDirectoryIfMissing )+import System.FilePath ( pathSeparator, splitFileName, (</>) )++import Agda.Interaction.FindFile ( findFile, findInterfaceFile )+import Agda.Interaction.Imports ( isNewerThan )+import Agda.Interaction.Options ( optCompileDir )+import Agda.Syntax.Common ( Nat, Arg, unArg )+import Agda.Syntax.Concrete.Name ( projectRoot )+import Agda.Syntax.Abstract.Name+  ( ModuleName(MName), QName(QName),+    mnameToList, qnameName, qnameModule, isInModule, nameId )+import Agda.Syntax.Internal+  ( Name, Args, Type,+    Clause(Clause), Pattern(VarP,DotP,LitP,ConP), Abs(Abs),+    ClauseBody(Body,NoBody,Bind),+    Term(Var,Lam,Lit,Level,Def,Con,Pi,Sort,MetaV,DontCare),+    toTopLevelModuleName, clausePats, clauseBody, arity, unEl, unAbs )+import Agda.TypeChecking.Substitute ( absBody )+import Agda.Syntax.Literal ( Literal(LitInt,LitFloat,LitString,LitChar,LitQName) )+import Agda.TypeChecking.Level ( reallyUnLevelView )+import Agda.TypeChecking.Monad+  ( TCM, Definition(Defn), Definitions, Interface,+    JSCode, Defn(Record,Datatype,Constructor,Primitive,Function,Axiom),+    iModuleName, iImportedModules, theDef, getConstInfo, typeOfConst,+    ignoreAbstractMode, miInterface, getVisitedModules,+    defName, defType, funClauses, funProjection,+    dataPars, dataIxs, dataClause, dataCons,+    conPars, conData, conSrcCon,+    recClause, recCon, recFields, recPars, recNamedCon,+    primClauses, defJSDef )+import Agda.TypeChecking.Monad.Options ( setCommandLineOptions, commandLineOptions, reportSLn )+import Agda.TypeChecking.Reduce ( instantiateFull, normalise )+import Agda.Utils.FileName ( filePath )+import Agda.Utils.Function ( iterate' )+import Agda.Utils.Monad ( (<$>), (<*>), bracket, ifM )+import Agda.Utils.IO.UTF8 ( writeFile )+import Agda.Utils.Impossible ( Impossible(Impossible), throwImpossible )+import Agda.Compiler.MAlonzo.Misc ( curDefs, curIF, curMName, setInterface )+import Agda.Compiler.MAlonzo.Primitives ( repl )++import Agda.Compiler.JS.Syntax+  ( Exp(Self,Local,Global,Undefined,String,Char,Integer,Double,Lambda,Object,Apply,Lookup),+    LocalId(LocalId), GlobalId(GlobalId), MemberId(MemberId), Export(Export), Module(Module),+    modName, expName, uses )+import Agda.Compiler.JS.Substitution+  ( curriedLambda, curriedApply, fix, emp, object, subst, apply )+import Agda.Compiler.JS.Case ( Tag(Tag), Case(Case), Patt(VarPatt,Tagged), lambda )+import Agda.Compiler.JS.Pretty ( pretty )++#include "../../undefined.h"++--------------------------------------------------+-- Entry point into the compiler+--------------------------------------------------++compilerMain :: Interface -> TCM ()+compilerMain mainI =+  -- Preserve the state (the compiler modifies the state).+  bracket get put $ \_ -> do++    -- Compute the output directory.+    opts <- commandLineOptions+    compileDir <- case optCompileDir opts of+      Just dir -> return dir+      Nothing  -> do+        -- The default output directory is the project root.+        let tm = toTopLevelModuleName $ iModuleName mainI+        f <- findFile tm+        return $ filePath $ projectRoot f tm+    setCommandLineOptions $+      opts { optCompileDir = Just compileDir }++    ignoreAbstractMode $ do+      mapM_ (compile . miInterface) =<< (elems <$> getVisitedModules)++compile :: Interface -> TCM ()+compile i = do+  setInterface i+  ifM uptodate noComp $ (yesComp >>) $ do+    writeModule =<< curModule+  where+  uptodate = liftIO =<< (isNewerThan <$> outFile_ <*> ifile)+  ifile    = maybe __IMPOSSIBLE__ filePath <$>+               (findInterfaceFile . toTopLevelModuleName =<< curMName)+  noComp   = reportSLn "" 1 . (++ " : no compilation is needed.").show =<< curMName+  yesComp  = reportSLn "" 1 . (`repl` "Compiling <<0>> in <<1>> to <<2>>") =<<+             sequence [show <$> curMName, ifile, outFile_] :: TCM ()++--------------------------------------------------+-- Naming+--------------------------------------------------++prefix  = "jAgda"++jsMod :: ModuleName -> GlobalId+jsMod m = GlobalId (prefix : map show (mnameToList m))++jsFileName :: GlobalId -> String+jsFileName (GlobalId ms) = intercalate "." ms ++ ".js"++jsMember :: Name -> MemberId+jsMember n =+  -- Anonymous fields are used for where clauses,+  -- and they're all given the concrete name "_",+  -- so we disambiguate them using their name id.+  case show n of+    "_" -> MemberId ("_" ++ show (nameId n))+    l   -> MemberId l++-- Rather annoyingly, the anonymous construtor of a record R in module M+-- is given the name M.recCon, but a named constructor C+-- is given the name M.R.C, sigh. This causes a lot of hoop-jumping+-- in the map from Agda names to JS names, which we patch by renaming+-- anonymous constructors to M.R.record.++global' :: QName -> TCM (Exp,[MemberId])+global' q = do+  i <- iModuleName <$> curIF+  is <- filter (isInModule q) <$> map (iModuleName . miInterface) <$> elems <$> getVisitedModules+  case is of+    [] -> __IMPOSSIBLE__+    _ -> let+        seg = maximum (map (length . mnameToList) is)+        ms = mnameToList (qnameModule q)+        m = MName (take seg ms)+        ls = map jsMember (drop seg ms ++ [qnameName q])+      in case (m == i) of+        True -> return (Self, ls)+        False -> return (Global (jsMod m), ls)++global :: QName -> TCM (Exp,[MemberId])+global q = do+  d <- getConstInfo q+  case d of+    Defn { theDef = Constructor { conData = p } } -> do+      e <- getConstInfo p+      case e of+        Defn { theDef = Record { recNamedCon = False } } -> do+          (m,ls) <- global' p+          return (m, ls ++ [MemberId "record"])+        _ -> global' (defName d)+    _ -> global' (defName d)++-- Reorder a list of exports to ensure def-before-use.+-- Note that this can diverge in the case when there is no such reordering.++reorder :: [Export] -> [Export]+reorder = reorder' empty++reorder' :: Set [MemberId] -> [Export] -> [Export]+reorder' defs [] = []+reorder' defs (e : es) =+  let us = uses e `difference` defs in+  case null us of+    True -> e : (reorder' (insert (expName e) defs) es)+    False -> reorder' defs (insertAfter us e es)++insertAfter :: Set [MemberId] -> Export -> [Export] -> [Export]+insertAfter us e []                 = [e]+insertAfter us e (f:fs) | null us   = e : f : fs+insertAfter us e (f:fs) | otherwise = f : insertAfter (delete (expName f) us) e fs++--------------------------------------------------+-- Main compiling clauses+--------------------------------------------------++curModule :: TCM Module+curModule = do+  m <- (jsMod <$> curMName)+  is <- map jsMod <$> (iImportedModules <$> curIF)+  es <- mapM definition =<< (toList <$> curDefs)+  return (Module m (reorder es))++definition :: (QName,Definition) -> TCM Export+definition (q,d) = do+  (_,ls) <- global q+  d <- instantiateFull d+  e <- defn q ls (defType d) (defJSDef d) (theDef d)+  return (Export ls e)++defn :: QName -> [MemberId] -> Type -> Maybe JSCode -> Defn -> TCM Exp+defn q ls t (Just e) Axiom =+  return e+defn q ls t Nothing Axiom = do+  t <- normalise t+  s <- isSingleton t+  case s of+    -- Inline and eta-expand postulates of singleton type+    Just e ->+      return (curriedLambda (arity t) e)+    -- Everything else we leave undefined+    Nothing ->+      return Undefined+defn q ls t (Just e) (Function {}) =+  return e+defn q ls t Nothing (Function { funProjection = proj, funClauses = cls }) = do+  t <- normalise t+  s <- isSingleton t+  cs <- mapM clause cls+  case s of+    -- Inline and eta-expand expressions of singleton type+    Just e ->+      return (curriedLambda (arity t) e)+    Nothing -> case proj of+      Just (p,i) -> do+        d <- getConstInfo p+        case theDef d of+          -- For projections from records we use a field lookup+          Record { recFields = flds } | q `elem` map unArg flds ->+            return (curriedLambda (numPars cls)+              (Lookup (Local (LocalId 0)) (last ls)))+          _ ->+            -- For anything else we generate code, after adding (i-1) dummy lambdas+            return (dummyLambda (i-1) (lambda cs))+      Nothing ->+        return (lambda cs)+defn q ls t (Just e) (Primitive {}) =+  return e+defn q ls t _ (Primitive {}) =+  return Undefined+defn q ls t _ (Datatype {}) =+  return emp+defn q ls t (Just e) (Constructor {}) =+  return e+defn q ls t _ (Constructor { conData = p, conPars = nc }) = do+  np <- return (arity t - nc)+  d <- getConstInfo p+  case theDef d of+    Record { recFields = flds } ->+      return (curriedLambda np (Object (fromList+        ( (last ls , Lambda 1+             (Apply (Lookup (Local (LocalId 0)) (last ls))+               [ Local (LocalId (np - i)) | i <- [0 .. np-1] ]))+        : (zip [ jsMember (qnameName (unArg fld)) | fld <- flds ]+             [ Local (LocalId (np - i)) | i <- [1 .. np] ])))))+    _ ->+      return (curriedLambda (np + 1)+        (Apply (Lookup (Local (LocalId 0)) (last ls))+          [ Local (LocalId (np - i)) | i <- [0 .. np-1] ]))+defn q ls t _ (Record {}) =+  return emp++-- Number of params in a function declaration++numPars :: [Clause] -> Nat+numPars []      = 0+numPars (c : _) = genericLength (clausePats c)++-- One clause in a function definition++clause :: Clause -> TCM Case+clause c = do+  ps <- mapM (pattern . unArg) (clausePats c)+  (av,bv,es) <- return (mapping (map unArg (clausePats c)))+  e <- body (clauseBody c)+  return (Case ps (subst av es e))++-- Mapping from Agda variables to JS variables in a pattern.+-- If mapping ps = (av,bv,es) then av is the number of Agda variables,+-- bv is the number of JS variables, and es is a list of expressions,+-- where es[i] is the JS variable corresponding to Agda variable i.++mapping :: [Pattern] -> (Nat,Nat,[Exp])+mapping = foldr mapping' (0,0,[])++mapping' :: Pattern -> (Nat,Nat,[Exp]) -> (Nat,Nat,[Exp])+mapping' (VarP _)      (av,bv,es) = (av+1, bv+1, Local (LocalId bv) : es)+mapping' (DotP _)      (av,bv,es) = (av+1, bv+1, Local (LocalId bv) : es)+mapping' (ConP _ _ ps) (av,bv,es) = (av',bv'+1,es') where+  (av',bv',es') = foldr mapping' (av,bv,es) (map unArg ps)+mapping' (LitP _)      (av,bv,es) = (av, bv+1, es)++-- Not doing literal patterns yet++pattern :: Pattern -> TCM Patt+pattern (ConP q _ ps) = do+  l <- tag q+  ps <- mapM (pattern . unArg) ps+  return (Tagged l ps)+pattern _             = return VarPatt++tag :: QName -> TCM Tag+tag q = do+  l <- visitorName q+  c <- getConstInfo q+  case theDef c of+    (Constructor { conData = p }) -> do+      d <- getConstInfo p+      case (defJSDef d, theDef d) of+        (Just e, Datatype { dataCons = qs }) -> do+          ls <- mapM visitorName qs+          return (Tag l ls (\ x xs -> apply e (x:xs)))+        (Nothing, Datatype { dataCons = qs }) -> do+          ls <- mapM visitorName qs+          return (Tag l ls Apply)+        (Just e, Record {}) -> do+          return (Tag l [l] (\ x xs -> apply e (x:xs)))+        (Nothing, Record {}) -> do+          return (Tag l [l] Apply)+        _ -> __IMPOSSIBLE__+    _ -> __IMPOSSIBLE__++visitorName :: QName -> TCM MemberId+visitorName q = do (m,ls) <- global q; return (last ls)++body :: ClauseBody -> TCM Exp+body (Body e) = term e+body (Bind b) = body (unAbs b)+body (NoBody) = return Undefined++term :: Term -> TCM Exp+term (Var   i as)         = do+  e <- return (Local (LocalId i))+  es <- args Nothing as+  return (curriedApply e es)+term (Lam   _ at)         = Lambda 1 <$> term (absBody at)+term (Lit   l)            = return (literal l)+term (Level l)            = term =<< reallyUnLevelView l+term (Def q as) = do+  d <- getConstInfo q+  case theDef d of+    -- Datatypes and records are erased+    Datatype {} -> return (String "*")+    Record {} -> return (String "*")+    _ -> case defJSDef d of+      -- Inline functions with an FFI definition+      Just e -> do+        es <- args (defProjection d) as+        return (curriedApply e es)+      Nothing -> do+        t <- normalise (defType d)+        s <- isSingleton t+        case s of+          -- Inline and eta-expand singleton types+          Just e ->+            return (curriedLambda (arity t) e)+          -- Everything else we leave non-inline+          Nothing -> do+            e <- qname q+            es <- args (defProjection d) as+            return (curriedApply e es)+term (Con q as) = do+  d <- getConstInfo q+  case defJSDef d of+    -- Inline functions with an FFI definition+    Just e -> do+      es <- args Nothing as+      return (curriedApply e es)+    -- Everything else we leave non-inline+    Nothing -> do+      e <- qname q+      es <- args Nothing as+      return (curriedApply e es)+term (Pi    _ _)          = return (String "*")+term (Sort  _)            = return (String "*")+term (MetaV _ _)          = return (Undefined)+term (DontCare _)         = return (Undefined)++-- Check to see if a type is a singleton, and if so, return its only+-- member.  Singleton types are of the form T1 -> ... -> Tn -> T where+-- T is either a record with no fields, a datatype with one+-- no-argument constructor, a datatype with no constructors,+-- or (since this is a type-erasing translation) Set.++isSingleton :: Type -> TCM (Maybe Exp)+isSingleton t = case unEl t of+  Pi _ b         -> isSingleton (unAbs b)+  Sort _         -> return (Just (String "*"))+  Def q as       -> do+    d <- getConstInfo q+    case (theDef d) of+      Datatype { dataPars = np, dataCons = [] } ->+        return (Just Undefined)+      Datatype { dataPars = np, dataCons = [p] } -> do+        c <- getConstInfo p+        case (arity (defType c) == np) of+          True -> Just <$> qname p+          False -> return (Nothing)+      Record { recCon = p, recFields = [] } ->+        Just <$> qname p+      _ -> return (Nothing)+  _              -> return (Nothing)++defProjection :: Definition -> Maybe (QName, Int)+defProjection Defn { theDef = Function { funProjection = p } } = p+defProjection _                                                = Nothing++args :: Maybe(QName, Int) -> Args -> TCM [Exp]+args Nothing as =+  mapM (term . unArg) as+args (Just (q,i)) as = do+  es <- mapM (term . unArg) as+  return (replicate (i-1) Undefined ++ es)++qname :: QName -> TCM Exp+qname q = do+  (e,ls) <- global q+  return (foldl Lookup e ls)++literal :: Literal -> Exp+literal (LitInt    _ x) = Integer x+literal (LitFloat  _ x) = Double  x+literal (LitString _ x) = String  x+literal (LitChar   _ x) = Char    x+literal (LitQName  _ x) = String  (show x)++dummyLambda :: Int -> Exp -> Exp+dummyLambda n = iterate' n (Lambda 0)++--------------------------------------------------+-- Writing out an ECMAScript module+--------------------------------------------------++writeModule :: Module -> TCM ()+writeModule m = do+  out <- outFile (modName m)+  liftIO (writeFile out (pretty 0 0 m))++compileDir :: TCM FilePath+compileDir = do+  mdir <- optCompileDir <$> commandLineOptions+  case mdir of+    Just dir -> return dir+    Nothing  -> __IMPOSSIBLE__++outFile :: GlobalId -> TCM FilePath+outFile m = do+  mdir <- compileDir+  let (fdir, fn) = splitFileName (jsFileName m)+  let dir = mdir </> fdir+      fp  = dir </> fn+  liftIO $ createDirectoryIfMissing True dir+  return fp++outFile_ :: TCM FilePath+outFile_ = do+  m <- curMName+  outFile (jsMod m)

+ src/full/Agda/Compiler/JS/Parser.hs view

@@ -0,0 +1,187 @@+module Agda.Compiler.JS.Parser where++-- This is a simple parser for the ECMAScript FFI, which parses a+-- subset of ECMAscript expressions. We do this so that we can+-- optimize code that contains FFI expressions, for example+-- {-# COMPILED_JS _+_ function (x) { return function (y) { return x+y; }; } #-}+-- will generate ECMAScript "1 + 2" from Agda "1 + 2".++import Prelude hiding ( exp, lookup )+import Control.Monad.Identity ( Identity )+import Data.List ( genericLength )+import Data.Char ( isSpace, isLetter, isAlphaNum, isDigit )+import Data.Map ( Map, fromList, union, empty )+import qualified Data.Map as M+import qualified Data.Map as M++import Agda.Utils.ReadP+  ( ReadP, (+++), (<++), between, chainl1, char, choice, look, many, many1,+    munch, munch1, parse', pfail, satisfy, sepBy, string, skipSpaces )++import Agda.Syntax.Common ( Nat )+import Agda.Compiler.JS.Syntax+  ( LocalId(LocalId), GlobalId(GlobalId), MemberId(MemberId),+    Exp(Self,Local,Global,Undefined,String,Integer,Lambda,Apply,Object,Lookup,If,BinOp,PreOp,Const) )++type Parser = ReadP Char++identifier :: Parser String+identifier = do+  c <- satisfy isLetter+  cs <- munch isAlphaNum+  skipSpaces+  return (c : cs)++wordBoundary :: Parser ()+wordBoundary = do+  cs <- look+  case cs of+    (c:_) | isAlphaNum c -> pfail+    _                    -> return ()++token :: String -> Parser ()+token s = string s >> wordBoundary >> skipSpaces++punct :: Char -> Parser ()+punct c = char c >> skipSpaces++parened :: Parser a -> Parser a+parened = between (punct '(')  (punct ')')++braced :: Parser a -> Parser a+braced = between (punct '{')  (punct '}')++bracketed :: Parser a -> Parser a+bracketed = between (punct '[')  (punct ']')++quoted :: Parser a -> Parser a+quoted = between (char '"') (punct '"')++stringLit :: Parser Exp+stringLit = do s <- stringStr; return (String s)++stringStr :: Parser String+stringStr = quoted (many stringChr)++stringChr :: Parser Char+stringChr = satisfy (`notElem` "\\\"") +++ escChr++-- Not handling all escape sequences+escChr :: Parser Char+escChr = char '\\' >> (+  (char 'n' >> return '\n') ++++  (char 'r' >> return '\r') ++++  (char 't' >> return '\t') ++++  (char '"' >> return '"') ++++  (char '\\' >> return '\\')+ )++-- Not handling all integer constants+intLit :: Parser Exp+intLit = do s <- munch1 isDigit; skipSpaces; return (Integer (read s))++undef :: Parser Exp+undef = token "undefined" >> return Undefined++localid :: (Map String Nat) -> Parser Exp+localid m = do+  s <- identifier+  case M.lookup s m of+    Nothing -> return (Const s)+    Just i -> return (Local (LocalId i))++globalid :: Parser Exp+globalid = do+  token "require"+  i <- parened (quoted (sepBy (munch1 isAlphaNum) (char '.')))+  return (Global (GlobalId i))++preop :: Parser String+preop = do+  op <- choice (map string [ "+", "-", "!" ])+  skipSpaces+  return op++binop :: Parser String+binop = do+  op <- choice (map string [+      "<", ">", "<=", ">=", "==", "===", "<<", ">>",+      "<<<", ">>>", "!=", "!==", "+", "-", "*", "%", "/",+      "&", "&&", "|", "||", "^"+    ])+  skipSpaces+  return op++field :: (Map String Nat) -> Parser (MemberId,Exp)+field m = do+  l <- stringStr+  punct ':'+  e <- exp m+  return (MemberId l, e)++object :: (Map String Nat) -> Parser Exp+object m = do+  o <- braced (sepBy (field m) (punct ','))+  return (Object (fromList o))++function :: (Map String Nat) -> Parser Exp+function m = do+  token "function"+  xs <- parened (sepBy identifier (punct ','))+  n <- return (genericLength xs)+  m' <- return (union (fromList (zip xs [n-1,n-2..0])) (M.map (+n) m))+  e <- bracedBlock m'+  return (Lambda n e)++bracedBlock :: (Map String Nat) -> Parser Exp+bracedBlock m = braced (returnBlock m +++ ifBlock m +++ bracedBlock m)++returnBlock :: (Map String Nat) -> Parser Exp+returnBlock m = between (token "return") (punct ';') (exp m)++ifBlock :: (Map String Nat) -> Parser Exp+ifBlock m = do+  token "if"+  e <- parened (exp m)+  f <- bracedBlock m+  token "else"+  g <- (ifBlock m +++ bracedBlock m)+  return (If e f g)++exp0 :: (Map String Nat) -> Parser Exp+exp0 m = function m <++ undef <++ globalid <++ localid m <+++         object m <++ stringLit <++ intLit <++ parened (exp m)++exp1 :: (Map String Nat) -> Parser Exp+exp1 m =+  (do op <- preop; e <- exp1 m; return (PreOp op e)) <+++  (exp0 m)++exp2 :: (Map String Nat) -> Parser Exp+exp2 m = exp1 m >>= exp2' m++-- Not handling operator fixity or precedence+exp2' :: (Map String Nat) -> Exp -> Parser Exp+exp2' m e =+  (do es <- parened (sepBy (exp m) (punct ',')); exp2' m (Apply e es)) <+++  (do i <- bracketed stringStr; exp2' m (Lookup e (MemberId i))) <+++  (do punct '.'; i <- identifier; exp2' m (Lookup e (MemberId i))) <+++  (do op <- binop; f <- exp0 m; exp2' m (BinOp e op f)) <+++  (return e)++exp3 :: (Map String Nat) -> Parser Exp+exp3 m = exp2 m >>= exp3' m++exp3' :: (Map String Nat) -> Exp -> Parser Exp+exp3' m e =+  (do punct '?'; f <- exp2 m; punct ':'; g <- exp2 m; return (If e f g)) <+++  (return e)++exp :: (Map String Nat) -> Parser Exp+exp = exp3++topLevel :: Parser Exp+topLevel = skipSpaces >> exp empty++parse :: String -> Either Exp String+parse = parse' topLevel

+ src/full/Agda/Compiler/JS/Pretty.hs view

@@ -0,0 +1,118 @@+module Agda.Compiler.JS.Pretty where++import Prelude hiding ( null )+import Data.List ( intercalate )+import Data.Set ( Set, toList, singleton, insert, member )+import Data.Map ( Map, toAscList, empty, null )++import Agda.Syntax.Common ( Nat )++import Agda.Compiler.JS.Syntax+  ( Exp(Self,Local,Global,Undefined,String,Char,Integer,Double,Lambda,Object,Apply,Lookup,If,BinOp,PreOp,Const),+    LocalId(LocalId), GlobalId(GlobalId), MemberId(MemberId), Module(Module), Export(Export),+    globals )++-- Pretty-print a lambda-calculus expression as ECMAScript.++-- Since ECMAScript is C-like rather than Haskell-like, it's easier to+-- do the pretty-printing directly than use the Pretty library, which+-- assumes Haskell-like indentation.++br :: Int -> String+br i = "\n" ++ take (2*i) (repeat ' ')++unescape :: Char -> String+unescape '"'      = "\\\""+unescape '\\'     = "\\\\"+unescape '\n'     = "\\n"+unescape '\r'     = "\\r"+unescape '\x2028' = "\\u2028"+unescape '\x2029' = "\\u2029"+unescape c        = [c]++unescapes :: String -> String+unescapes s = concat (map unescape s)++-- pretty n i e pretty-prints e, under n levels of de Bruijn binding,+-- with i levels of indentation.++class Pretty a where+    pretty :: Nat -> Int -> a -> String++instance (Pretty a, Pretty b) => Pretty (a,b) where+  pretty n i (x,y) = pretty n i x ++ ": " ++ pretty n (i+1) y++-- Pretty-print collections++class Pretties a where+    pretties :: Nat -> Int -> a -> [String]++instance Pretty a => Pretties [a] where+  pretties n i = map (pretty n i)++instance (Pretty a, Pretty b) => Pretties (Map a b) where+  pretties n i o = pretties n i (toAscList o)++-- Pretty print identifiers++instance Pretty LocalId where+  pretty n i (LocalId x) = "x" ++ show (n - x - 1)++instance Pretty GlobalId where+  pretty n i (GlobalId m) = intercalate "_" m++instance Pretty MemberId where+  pretty n i (MemberId s) = "\"" ++ unescapes s ++ "\""++-- Pretty print expressions++instance Pretty Exp where+  pretty n i (Self)                 = "exports"+  pretty n i (Local x)              = pretty n i x+  pretty n i (Global m)             = pretty n i m+  pretty n i (Undefined)            = "undefined"+  pretty n i (String s)             = "\"" ++ unescapes s ++ "\""+  pretty n i (Char c)               = "\"" ++ unescape c ++ "\""+  pretty n i (Integer x)            = show x+  pretty n i (Double x)             = show x+  pretty n i (Lambda x e)           =+    "function (" +++      intercalate ", " (pretties (n+x) i (map LocalId [x-1, x-2 .. 0])) +++    ") " ++ block (n+x) i e+  pretty n i (Object o) | null o    = "{}"+  pretty n i (Object o) | otherwise =+    "{" ++ br (i+1) ++ intercalate ("," ++ br (i+1)) (pretties n i o) ++ br i ++ "}"+  pretty n i (Apply f es)           = pretty n i f ++ "(" ++ intercalate ", " (pretties n i es) ++ ")"+  pretty n i (Lookup e l)           = pretty n i e ++ "[" ++ pretty n i l ++ "]"+  pretty n i (If e f g)             =+    "(" ++ pretty n i e ++ "? " ++ pretty n i f ++ ": " ++ pretty n i g ++ ")"+  pretty n i (PreOp op e)           = "(" ++ op ++ " " ++ pretty n i e ++ ")"+  pretty n i (BinOp e op f)         = "(" ++ pretty n i e ++ " " ++ op ++ " " ++ pretty n i f ++ ")"+  pretty n i (Const c)              = c++block :: Nat -> Int -> Exp -> String+block n i (If e f g) = "{" ++ br (i+1) ++ block' n (i+1) (If e f g) ++ br i ++ "}"+block n i e          = "{" ++ br (i+1) ++ "return " ++ pretty n (i+1) e ++ ";" ++ br i ++ "}"++block' :: Nat -> Int -> Exp -> String+block' n i (If e f g) = "if (" ++ pretty n i e ++ ") " ++ block n i f ++ " else " ++ block' n i g+block' n i e          = block n i e++modname :: GlobalId -> String+modname (GlobalId ms) = "\"" ++ intercalate "." ms ++ "\""++exports :: Nat -> Int -> Set [MemberId] -> [Export] -> String+exports n i lss [] = ""+exports n i lss (Export ls e : es) | member (init ls) lss =+  "exports[" ++ intercalate "][" (pretties n i ls) ++ "] = " ++ pretty n (i+1) e ++ ";" ++ br i +++  exports n i (insert ls lss) es+exports n i lss (Export ls e : es) | otherwise =+  exports n i lss (Export (init ls) (Object empty) : Export ls e : es)++instance Pretty Module where+  pretty n i (Module m es) =+    "define([" ++ intercalate "," ("\"exports\"" : map modname js) ++ "]," +++    "function(" ++ intercalate "," ("exports" : pretties n i js) ++ ") {" ++ br (i+1) +++    exports n (i+1) (singleton []) es +++    "});" ++ br i+      where js = toList (globals es)

+ src/full/Agda/Compiler/JS/Substitution.hs view

@@ -0,0 +1,124 @@+module Agda.Compiler.JS.Substitution where++import Prelude hiding ( map, lookup )+import Data.Generics ( Data, Typeable )+import Data.Map ( Map, empty, toList, unionWith, singleton, findWithDefault )+import qualified Data.Map as M ( map )+import Data.Map ( Map )+import Data.List ( genericIndex )+import qualified Data.List as L ( map )++import Agda.Syntax.Common ( Nat )+import Agda.Compiler.JS.Syntax+  ( Exp(Self,Undefined,Local,Lambda,Object,Apply,Lookup,If,BinOp,PreOp),+    MemberId, LocalId(LocalId), GlobalId(GlobalId) )+import Agda.Utils.Function ( iterate' )++-- Map for expressions++map :: Nat -> (Nat -> LocalId -> Exp) -> Exp -> Exp+map m f (Local i)       = f m i+map m f (Lambda i e)    = Lambda i (map (m + i) f e)+map m f (Object o)      = Object (M.map (map m f) o)+map m f (Apply e es)    = Apply (map m f e) (L.map (map m f) es)+map m f (Lookup e l)    = Lookup (map m f e) l+map m f (If e e' e'')   = If (map m f e) (map m f e') (map m f e'')+map m f (PreOp op e)    = PreOp op (map m f e)+map m f (BinOp e op e') = BinOp (map m f e) op (map m f e')+map m f e               = e++-- Shifting++shift :: Nat -> Exp -> Exp+shift = shiftFrom 0++shiftFrom :: Nat -> Nat -> Exp -> Exp+shiftFrom m 0 e = e+shiftFrom m n e = map m (shifter n) e++shifter :: Nat -> Nat -> LocalId -> Exp+shifter n m (LocalId i) | i < m     = Local (LocalId i)+shifter n m (LocalId i) | otherwise = Local (LocalId (i + n))++-- Substitution++subst :: Nat -> [Exp] -> Exp -> Exp+subst 0 es e = e+subst n es e = map 0 (substituter n es) e++substituter :: Nat -> [Exp] -> Nat -> LocalId -> Exp+substituter n es m (LocalId i) | i < m       = Local (LocalId i)+substituter n es m (LocalId i) | (i - m) < n = shift m (genericIndex (es ++ repeat Undefined) (n - (i + 1 - m)))+substituter n es m (LocalId i) | otherwise   = Local (LocalId (i - n))++-- A variant on substitution which performs beta-reduction++map' :: Nat -> (Nat -> LocalId -> Exp) -> Exp -> Exp+map' m f (Local i)       = f m i+map' m f (Lambda i e)    = Lambda i (map' (m + i) f e)+map' m f (Object o)      = Object (M.map (map' m f) o)+map' m f (Apply e es)    = apply (map' m f e) (L.map (map' m f) es)+map' m f (Lookup e l)    = lookup (map' m f e) l+map' m f (If e e' e'')   = If (map' m f e) (map' m f e') (map' m f e'')+map' m f (PreOp op e)    = PreOp op (map' m f e)+map' m f (BinOp e op e') = BinOp (map' m f e) op (map' m f e')+map' m f e               = e++subst' :: Nat -> [Exp] -> Exp -> Exp+subst' 0 es e = e+subst' n es e = map' 0 (substituter n es) e++-- Beta-reducing application and field access++apply :: Exp -> [Exp] -> Exp+apply (Lambda i e) es = subst' i es e+apply e            es = Apply e es++lookup :: Exp -> MemberId -> Exp+lookup (Object o) l = findWithDefault Undefined l o+lookup e          l = Lookup e l++-- Replace any top-level occurrences of self+-- (needed because JS is a cbv language, so any top-level+-- recursions would evaluate before the module has been defined,+-- e.g. exports = { x: 1, y: exports.x } results in an exception,+-- as exports is undefined at the point that exports.x is evaluated),++self :: Exp -> Exp -> Exp+self e (Self)         = e+self e (Object o)     = Object (M.map (self e) o)+self e (Apply f es)   = case (self e f) of+  (Lambda n g) -> self e (subst' n es g)+  g            -> Apply g (L.map (self e) es)+self e (Lookup f l)   = lookup (self e f) l+self e (If f g h)     = If (self e f) (self e g) (self e h)+self e (BinOp f op g) = BinOp (self e f) op (self e g)+self e (PreOp op f)   = PreOp op (self e f)+self e f              = f++-- Find the fixed point of an expression, with no top-level occurrences+-- of self.++fix :: Exp -> Exp+fix f = e where e = self e f++-- Some helper functions++curriedApply :: Exp -> [Exp] -> Exp+curriedApply = foldl (\ f e -> apply f [e])++curriedLambda :: Nat -> Exp -> Exp+curriedLambda n = iterate' n (Lambda 1)++emp :: Exp+emp = Object (empty)++union :: Exp -> Exp -> Exp+union (Object o) (Object p) = Object (unionWith union o p)+union e          f          = e++vine :: [MemberId] -> Exp -> Exp+vine ls e = foldr (\ l e -> Object (singleton l e)) e ls++object :: [([MemberId],Exp)] -> Exp+object = foldr (\ (ls,e) -> (union (vine ls e))) emp

+ src/full/Agda/Compiler/JS/Syntax.hs view

@@ -0,0 +1,110 @@+{-# LANGUAGE DeriveDataTypeable+  #-}+module Agda.Compiler.JS.Syntax where++import Data.Generics ( Data, Typeable )+import Data.Map ( Map, fold )+import Data.Set ( Set, empty, singleton, union )++import Agda.Syntax.Common ( Nat )++-- An untyped lambda calculus with records,+-- and a special self-binder for recursive declarations++data Exp =+  Self |+  Local LocalId |+  Global GlobalId |+  Undefined |+  String String |+  Char Char |+  Integer Integer |+  Double Double |+  Lambda Nat Exp |+  Object (Map MemberId Exp) |+  Apply Exp [Exp] |+  Lookup Exp MemberId |+  If Exp Exp Exp |+  BinOp Exp String Exp |+  PreOp String Exp |+  Const String+  deriving (Typeable, Data, Show)++-- Local identifiers are named by De Bruijn indices.+-- Global identifiers are named by string lists.+-- Object members are named by strings.++newtype LocalId = LocalId Nat+  deriving (Typeable, Data, Eq, Ord, Show)++newtype GlobalId = GlobalId [String]+  deriving (Typeable, Data, Eq, Ord, Show)++newtype MemberId = MemberId String+  deriving (Typeable, Data, Eq, Ord, Show)++-- The top-level compilation unit is a module, which names+-- the GId of its exports, and a list of definitions++data Export = Export { expName :: [MemberId], defn :: Exp }+  deriving (Typeable, Data, Show)++data Module = Module { modName :: GlobalId, exports :: [Export] }+  deriving (Typeable, Data, Show)++-- Note that modules are allowed to be recursive, via the Self expression,+-- which is bound to the exported module.++-- Top-level uses of the form exports.l1....lN.++class Uses a where+  uses :: a -> Set [MemberId]++instance Uses a => Uses [a] where+  uses = foldr (union . uses) empty++instance Uses a => Uses (Map k a) where+  uses = fold (union . uses) empty++instance Uses Exp where+  uses (Object o)     = fold (union . uses) empty o+  uses (Apply e es)   = foldr (union . uses) (uses e) es+  uses (Lookup e l)   = uses' e [l] where+      uses' Self         ls = singleton ls+      uses' (Lookup e l) ls = uses' e (l : ls)+      uses' e            ls = uses e+  uses (If e f g)     = uses e `union` uses f `union` uses g+  uses (BinOp e op f) = uses e `union` uses f+  uses (PreOp op e)   = uses e+  uses e              = empty++instance Uses Export where+  uses (Export ls e) = uses e++-- All global ids++class Globals a where+  globals :: a -> Set GlobalId++instance Globals a => Globals [a] where+  globals = foldr (union . globals) empty++instance Globals a => Globals (Map k a) where+  globals = fold (union . globals) empty++instance Globals Exp where+  globals (Global i) = singleton i+  globals (Lambda n e) = globals e+  globals (Object o) = globals o+  globals (Apply e es) = globals e `union` globals es+  globals (Lookup e l) = globals e+  globals (If e f g) = globals e `union` globals f `union` globals g+  globals (BinOp e op f) = globals e `union` globals f+  globals (PreOp op e) = globals e+  globals _ = empty++instance Globals Export where+  globals (Export ls e) = globals e++instance Globals Module where+  globals (Module m es) = globals es

src/full/Agda/Compiler/MAlonzo/Compiler.hs view

@@ -1,4 +1,4 @@-{-# LANGUAGE CPP #-}+{-# LANGUAGE CPP, PatternGuards #-}  module Agda.Compiler.MAlonzo.Compiler where @@ -26,7 +26,6 @@ import Agda.Compiler.MAlonzo.Primitives import Agda.Interaction.FindFile import Agda.Interaction.Imports-import Agda.Interaction.Monad import Agda.Interaction.Options import Agda.Syntax.Common import qualified Agda.Syntax.Concrete.Name as CN@@ -37,6 +36,8 @@ import Agda.TypeChecking.Reduce import Agda.TypeChecking.Rules.Builtin.Coinduction import Agda.TypeChecking.Pretty+import Agda.TypeChecking.Substitute+import Agda.TypeChecking.Level (reallyUnLevelView) import Agda.Utils.FileName import Agda.Utils.Monad import qualified Agda.Utils.IO.Locale as LocIO@@ -116,8 +117,8 @@ -- @ --   type Infinity a b = b -----   sharp :: forall a. () -> forall b. () -> b -> b---   sharp _ _ x = x+--   sharp :: a -> a+--   sharp x = x -- --   flat :: forall a. () -> forall b. () -> b -> b --   flat _ _ x = x@@ -125,12 +126,16 @@  definition :: Maybe CoinductionKit -> Definition -> TCM [HS.Decl] -- ignore irrelevant definitions-definition kit (Defn Forced     _ _  _ _ _) = __IMPOSSIBLE__-definition kit (Defn Irrelevant _ _  _ _ _) = return []-definition kit (Defn Relevant   q ty _ _ d) = do+definition kit (Defn Forced     _ _  _ _ _ _) = __IMPOSSIBLE__+definition kit (Defn NonStrict  _ _  _ _ _ _) = __IMPOSSIBLE__+definition kit (Defn Irrelevant _ _  _ _ _ _) = return []+definition kit (Defn Relevant   q ty _ _ compiled d) = do   checkTypeOfMain q ty   (infodecl q :) <$> case d of +    _ | Just (HsDefn ty hs) <- compiledHaskell compiled ->+      return $ fbWithType ty (fakeExp hs)+     -- Special treatment of coinductive builtins.     Datatype{} | Just q == (nameOfInf <$> kit) -> do       let infT = unqhname "T" q@@ -151,9 +156,9 @@           x     = ihname "x" 0       return $         [ HS.TypeSig dummy [sharp] $ fakeType $-            "forall a. () -> forall b. () -> b -> b"+            "forall a. a -> a"         , HS.FunBind [HS.Match dummy sharp-                               [HS.PWildCard, HS.PWildCard, HS.PVar x]+                               [HS.PVar x]                                Nothing                                (HS.UnGuardedRhs (HS.Var (HS.UnQual x)))                                (HS.BDecls [])]@@ -171,30 +176,29 @@                                (HS.BDecls [])]         ] -    Axiom{ axHsDef = Just (HsDefn ty hs) } -> return $ fbWithType ty (fakeExp hs)     Axiom{}                                -> return $ fb axiomErr     Function{ funClauses =        cls } -> function cls     Primitive{ primClauses = Just cls } -> function cls     Primitive{ primClauses = Nothing, primName = s } -> fb <$> primBody s-    Datatype{ dataPars = np, dataIxs = ni, dataClause = cl, dataCons = cs, dataHsType = Just ty } -> do+    Datatype{ dataPars = np, dataIxs = ni, dataClause = cl, dataCons = cs }+      | Just (HsType ty) <- compiledHaskell compiled -> do       ccs <- concat <$> mapM checkConstructorType cs       cov <- checkCover q ty np cs       return $ tvaldecl q (dataInduction d) 0 (np + ni) [] (Just __IMPOSSIBLE__) ++ ccs ++ cov-    Datatype{ dataPars = np, dataIxs = ni, dataClause = cl, dataCons = cs, dataHsType = Nothing } -> do+    Datatype{ dataPars = np, dataIxs = ni, dataClause = cl, dataCons = cs } -> do       (ars, cds) <- unzip <$> mapM condecl cs       return $ tvaldecl q (dataInduction d) (maximum (np:ars) - np) (np + ni) cds cl     Constructor{} -> return []     Record{ recClause = cl, recCon = c, recFields = flds } -> do       let noFields = genericLength flds-      ar <- arity <$> normalise ty+      let ar = arity ty       cd <- snd <$> condecl c --       cd <- case c of --         Nothing -> return $ cdecl q noFields --         Just c  -> snd <$> condecl c       return $ tvaldecl q Inductive noFields ar [cd] cl   where-  function cls = mkwhere <$> mapM (clause q)-                                  (tag 0 $ L.map translatedClause cls)+  function cls = mkwhere <$> mapM (clause q) (tag 0 cls)   tag _ []       = []   tag i [cl]     = (i, True , cl): []   tag i (cl:cls) = (i, False, cl): tag (i + 1) cls@@ -210,7 +214,7 @@  checkConstructorType :: QName -> TCM [HS.Decl] checkConstructorType q = do-  Constructor{ conHsCode = Just (ty, hs) } <- theDef <$> getConstInfo q+  Just (HsDefn ty hs) <- compiledHaskell . defCompiledRep <$> getConstInfo q   return [ HS.TypeSig dummy [unqhname "check" q] $ fakeType ty          , HS.FunBind [HS.Match dummy (unqhname "check" q) [] Nothing                                 (HS.UnGuardedRhs $ fakeExp hs) (HS.BDecls [])]@@ -220,8 +224,8 @@ checkCover q ty n cs = do   let tvs = [ "a" ++ show i | i <- [1..n] ]       makeClause c = do-        a <- constructorArity c-        Just (_, hsc) <- conHsCode . theDef <$> getConstInfo c+        (a, _) <- conArityAndPars c+        Just (HsDefn _ hsc) <- compiledHaskell . defCompiledRep <$> getConstInfo c         let pat = HS.PApp (HS.UnQual $ HS.Ident hsc) $ genericReplicate a HS.PWildCard         return $ HS.Alt dummy pat (HS.UnGuardedAlt $ HS.Tuple []) (HS.BDecls [])   cs <- mapM makeClause cs@@ -235,13 +239,13 @@          ]  -- | Move somewhere else!-constructorArity :: MonadTCM tcm => QName -> tcm Nat-constructorArity q = do+conArityAndPars :: QName -> TCM (Nat, Nat)+conArityAndPars q = do   def <- getConstInfo q-  a <- normalise $ defType def-  case theDef def of-    Constructor{ conPars = np } -> return $ arity a - np-    _ -> fail $ "constructorArity: non constructor: " ++ show q+  TelV tel _ <- telViewM $ defType def+  let Constructor{ conPars = np } = theDef def+      n = genericLength (telToList tel)+  return (n - np, np)  clause :: QName -> (Nat, Bool, Clause) -> TCM HS.Decl clause q (i, isLast, Clause{ clausePats = ps, clauseBody = b }) =@@ -251,14 +255,15 @@        | isLast                 = []        | otherwise              = [match (L.map HS.PVar cvs) crhs]   cvs  = L.map (ihname "v") [0 .. genericLength ps - 1]-  crhs = hsCast$ foldl HS.App (hsVarUQ $ dsubname q (i + 1)) (L.map hsVarUQ cvs)-  failrhs = rtmError $ "incomplete pattern matching: " ++ show q+  crhs = hsCast$ L.foldl HS.App (hsVarUQ $ dsubname q (i + 1)) (L.map hsVarUQ cvs)+  failrhs = rtmIncompleteMatch q  -- Andreas, 2011-11-16 call to RTE instead of inlined error+--  failrhs = rtmError $ "incomplete pattern matching: " ++ show q   match hps rhs = HS.Match dummy (dsubname q i) hps Nothing                            (HS.UnGuardedRhs rhs) (HS.BDecls [])-  bvars (Body _)          _ = []-  bvars (Bind (Abs _ b')) n = HS.PVar (ihname "v" n) : bvars b' (n + 1)-  bvars (NoBind      b' ) n = HS.PWildCard           : bvars b' n -- WHY NOT: bvars b' n  -- PRODDUCES head [] exception-  bvars NoBody            _ = repeat HS.PWildCard -- ?+  bvars (Body _)           _ = []+  bvars (Bind (Abs _ b'))  n = HS.PVar (ihname "v" n) : bvars b' (n + 1)+  bvars (Bind (NoAbs _ b)) n = HS.PWildCard : bvars b n+  bvars NoBody             _ = repeat HS.PWildCard -- ?    isCon (Arg _ _ ConP{}) = True   isCon _                = False@@ -304,9 +309,9 @@  clausebody :: ClauseBody -> TCM HS.Exp clausebody b0 = runReaderT (go b0) 0 where-  go (Body   tm       ) = hsCast <$> term tm-  go (Bind   (Abs _ b)) = local (1+) $ go b-  go (NoBind b        ) = go b+  go (Body tm       )   = hsCast <$> term tm+  go (Bind (Abs _ b))   = local (1+) $ go b+  go (Bind (NoAbs _ b)) = go b   go NoBody             = return $ rtmError $ "Impossible Clause Body"  -- | Extract Agda term to Haskell expression.@@ -320,12 +325,16 @@                               local (1+) (term $ absBody at)   Lit   l    -> lift $ literal l   Def   q as -> (`apps` as) . HS.Var =<< lift (xhqn "d" q)-  Con   q as -> (`apps` as) . HS.Con =<< lift (conhqn q)+  Con   q as -> do+    kit <- lift coinductionKit+    if Just q == (nameOfSharp <$> kit)+      then (`apps` as) . HS.Var =<< lift (xhqn "d" q)+      else (`apps` as) . HS.Con =<< lift (conhqn q)+  Level l    -> term =<< lift (reallyUnLevelView l)   Pi    _ _  -> return HS.unit_con-  Fun   _ _  -> return HS.unit_con   Sort  _    -> return HS.unit_con   MetaV _ _  -> mazerror "hit MetaV"-  DontCare   -> return $ rtmError $ "hit DontCare"+  DontCare _ -> return $ rtmError $ "hit DontCare"   where apps =  foldM (\h a -> HS.App h <$> term' a)  -- | Irrelevant arguments are replaced by Haskells' ().@@ -338,24 +347,32 @@   LitInt    _ _   -> do toN <- bltQual "NATURAL" mazIntegerToNat                         return $ HS.Var toN `HS.App` typed "Integer"   LitFloat  _ _   -> return $ typed "Double"+  LitQName  _ x   -> litqname x   _               -> return $ l'   where l'    = HS.Lit $ hslit l         typed = HS.ExpTypeSig dummy l' . HS.TyCon . rtmQual  hslit :: Literal -> HS.Literal hslit l = case l of LitInt    _ x -> HS.Int    x-                    LitLevel  _ x -> HS.Int    x                     LitFloat  _ x -> HS.Frac   (toRational x)                     LitString _ x -> HS.String x                     LitChar   _ x -> HS.Char   x-                    LitQName  _ x -> HS.String (show x)+                    LitQName  _ x -> __IMPOSSIBLE__ +litqname :: QName -> TCM HS.Exp+litqname x = return $+  HS.Con (HS.Qual mazRTE $ HS.Ident "QName") `HS.App`+  HS.Lit (HS.Int n) `HS.App`+  HS.Lit (HS.Int m) `HS.App`+  (rtmError "primQNameType: not implemented") `HS.App`+  (rtmError "primQNameDefinition: not implemented")+  where+    NameId n m = nameId $ qnameName x+ condecl :: QName -> TCM (Nat, HS.ConDecl)-condecl q = getConstInfo q >>= \d -> case d of-  Defn _ _ ty _ _ (Constructor {conPars = np}) -> do-    ar <- arity <$> normalise ty-    return $ (ar, cdecl q (ar - np))-  _ -> mazerror $ "condecl:" ++ gshow' (q, d)+condecl q = do+  (ar, np) <- conArityAndPars q+  return $ (ar + np, cdecl q ar)  cdecl :: QName -> Nat -> HS.ConDecl cdecl q n = HS.ConDecl (unqhname "C" q)@@ -438,6 +455,14 @@   , "{-# INLINE [1] mazCoerce #-}"   , "mazCoerce = Unsafe.Coerce.unsafeCoerce"   , "{-# RULES \"coerce-id\" forall (x :: a) . mazCoerce x = x #-}"+  , ""+  , "-- Builtin QNames, the third field is for the type."+  , "data QName a b = QName { nameId, moduleId :: Integer, qnameType :: a, qnameDefinition :: b }"+  , "instance Eq (QName a b) where"+  , "  QName a b _ _ == QName c d _ _ = (a, b) == (c, d)"+  , ""+  , "mazIncompleteMatch :: String -> a"+  , "mazIncompleteMatch s = error (\"MAlonzo Runtime Error: incomplete pattern matching: \" ++ s)"   ]   where     parse = HS.parseWithMode

src/full/Agda/Compiler/MAlonzo/Misc.hs view

@@ -14,7 +14,6 @@ import System.Time  import Agda.Interaction.Imports-import Agda.Interaction.Monad import Agda.Syntax.Common import qualified Agda.Syntax.Concrete.Name as C import Agda.Syntax.Internal@@ -116,10 +115,12 @@ -- always use the original name for a constructor even when it's redefined. conhqn :: QName -> TCM HS.QName conhqn q = do-    cq   <- canonicalName q-    defn <- theDef <$> getConstInfo cq-    case defn of Constructor{conHsCode = Just (_, hs)} -> return $ HS.UnQual $ HS.Ident hs-                 _                                     -> xhqn "C" cq+    cq  <- canonicalName q+    def <- getConstInfo cq+    hsr <- compiledHaskell . defCompiledRep <$> getConstInfo cq+    case (compiledHaskell (defCompiledRep def), theDef def) of+      (Just (HsDefn _ hs), Constructor{}) -> return $ HS.UnQual $ HS.Ident hs+      _                                   -> xhqn "C" cq  -- qualify name s by the module of builtin b bltQual :: String -> String -> TCM HS.QName@@ -144,6 +145,11 @@ mazerror msg = error $ mazstr ++ ": " ++ msg -- mazCoerce = HS.Var $ HS.Qual unsafeCoerceMod (HS.Ident "unsafeCoerce") mazCoerce = HS.Var $ HS.Qual mazRTE $ HS.Ident "mazCoerce"++-- Andreas, 2011-11-16: error incomplete match now RTE-call+mazIncompleteMatch = HS.Var $ HS.Qual mazRTE $ HS.Ident "mazIncompleteMatch"+rtmIncompleteMatch :: QName -> HS.Exp+rtmIncompleteMatch q = mazIncompleteMatch `HS.App` hsVarUQ (unqhname "name" q)  mazRTE :: HS.ModuleName mazRTE = HS.ModuleName "MAlonzo.RTE"

src/full/Agda/Compiler/MAlonzo/Primitives.hs view

@@ -24,7 +24,7 @@ checkTypeOfMain q ty   | show (qnameName q) /= "main" = return ()   | otherwise = do-    Def io [] <- primIO+    Def io _ <- primIO     ty <- normalise ty     case unEl ty of       Def d _ | d == io -> return ()@@ -183,14 +183,18 @@   , "primStringEquality" |-> rel "(==)" "String"   , "primShowString"     |-> return "(show :: String -> String)" -  -- QNames-  , "primQNameEquality" |-> rel "(==)" "String"+  -- Reflection+  , "primQNameEquality"   |-> rel "(==)" "MAlonzo.RTE.QName () ()"+  , "primQNameType"       |-> return "MAlonzo.RTE.qnameType"+  , "primQNameDefinition" |-> return "MAlonzo.RTE.qnameDefinition" +  , "primDataConstructors" |-> return "(error \"primDataConstructors: not implemented\")"+   -- Trust me   , ("primTrustMe"       , Right <$> do        refl <- primRefl        flip runReaderT 0 $-         term $ lam "A" (lam "x" (lam "y" refl)))+         term $ lam "a" (lam "A" (lam "x" (lam "y" refl))))   ]   where   x |-> s = (x, Left <$> s)@@ -226,18 +230,19 @@  pconName :: String -> TCM String pconName s = toS =<< getBuiltin s where-  toS (Con q _)         = prettyPrint <$> conhqn q-  toS (Lam _ (Abs _ t)) = toS t+  toS (Con q _) = prettyPrint <$> conhqn q+  toS (Lam _ t) = toS (unAbs t)   toS _ = mazerror $ "pconName" ++ s  hasCompiledData :: [String] -> TCM Bool hasCompiledData (s:_) = toB =<< getBuiltin s where   toB (Con q _)         = do     def <- getConstInfo =<< ignoreAbstractMode (canonicalName q)-    return $ case theDef def of Constructor{conHsCode = Just _} -> True-                                _                               -> False-  toB (Lam _ (Abs _ t)) = toB t-  toB _                 = return False+    return $ case compiledHaskell $ defCompiledRep def of+      Just{}  -> True+      Nothing -> False+  toB (Lam _ t) = toB (unAbs t)+  toB _         = return False hasCompiledData _    = return False

src/full/Agda/Interaction/BasicOps.hs view

@@ -1,13 +1,10 @@ {-# LANGUAGE CPP, MultiParamTypeClasses, FlexibleInstances,-             UndecidableInstances+             UndecidableInstances, DeriveFunctor   #-}  module Agda.Interaction.BasicOps where-{- TODO: The operations in this module should return Expr and not String,-         for this we need to write a translator from Internal to Abstract syntax.--} -+import Control.Applicative import Control.Monad.Error import Control.Monad.Reader import Control.Monad.State@@ -16,8 +13,6 @@ import Data.List import Data.Maybe -import Agda.Interaction.Monad- import qualified Agda.Syntax.Concrete as C -- ToDo: Remove with instance of ToConcrete import Agda.Syntax.Position import Agda.Syntax.Abstract as A hiding (Open)@@ -42,9 +37,12 @@ import Agda.TypeChecking.EtaContract (etaContract) import Agda.TypeChecking.Coverage import Agda.TypeChecking.Records+import Agda.TypeChecking.Irrelevance (wakeIrrelevantVars) import Agda.TypeChecking.Pretty (prettyTCM)+import Agda.TypeChecking.Eliminators (unElim) import qualified Agda.TypeChecking.Pretty as TP +import Agda.Utils.List import Agda.Utils.Monad import Agda.Utils.Pretty import Agda.Utils.Permutation@@ -71,7 +69,7 @@     concreteToAbstract (clScope mi) e  giveExpr :: MetaId -> Expr -> TCM Expr--- When translater from internal to abstract is given, this function might return+-- When translator from internal to abstract is given, this function might return -- the expression returned by the type checker. giveExpr mi e =     do  mv <- lookupMeta mi@@ -84,11 +82,10 @@ 		    let t' = t `piApply` ctx 		    v	<- checkExpr e t' 		    case mvInstantiation mv of-			InstV v' ->-			  addConstraints =<< equalTerm t' v (v' `apply` ctx)+			InstV v' -> equalTerm t' v (v' `apply` ctx) 			_	 -> updateMeta mi v 		    reify v-		 IsSort _ -> __IMPOSSIBLE__+		 IsSort{} -> __IMPOSSIBLE__  give :: InteractionId -> Maybe Range -> Expr -> TCM (Expr,[InteractionId]) give ii mr e = liftTCM $ do@@ -115,8 +112,6 @@   refine :: InteractionId -> Maybe Range -> Expr -> TCM (Expr,[InteractionId])--- If constants has a fixed arity, then it might be better to do--- exact refinement. refine ii mr e =     do  mi <- lookupInteractionId ii         mv <- lookupMeta mi@@ -139,47 +134,10 @@                  --ToDo: The position of metaVar is not correct                  --ToDo: The fixity of metavars is not correct -- fixed? MT -{--refineExact :: InteractionId -> Maybe Range -> Expr -> TCM (Expr,[InteractionId])-refineExact ii mr e =-    do  mi <- lookupInteractionId ii-        mv <- lookupMeta mi-        let range = maybe (getRange mv) id mr-        let scope = M.getMetaScope mv-        (_,t) <- withMetaInfo (getMetaInfo mv) $ inferExpr e-        let arityt = arity t--        tryRefine 10 range scope e-  where tryRefine :: Int -> Range -> ScopeInfo -> Expr -> TCM (Expr,[InteractionId])-        tryRefine nrOfMetas r scope e = try nrOfMetas e-           where try 0 e = throwError (strMsg "Can not refine")-                 try n e = give ii (Just r) e `catchError` (\_ -> try (n-1) (appMeta e))-                 appMeta :: Expr -> Expr-                 appMeta e =-                      let metaVar = QuestionMark $ Agda.Syntax.Info.MetaInfo {Agda.Syntax.Info.metaRange = r,-                                                 Agda.Syntax.Info.metaScope = scope}-                      in App (ExprRange $ r) NotHidden e metaVar-                 --ToDo: The position of metaVar is not correct------abstract :: InteractionId -> Maybe Range -> TCM (Expr,[InteractionId])-abstract ii mr---refineExact :: InteractionId -> Expr -> TCM (Expr,[InteractionId])-refineExact ii e =-    do--}-- {-| Evaluate the given expression in the current environment -} evalInCurrent :: Expr -> TCM Expr evalInCurrent e =-    do  t <- newTypeMeta_-	v <- checkExpr e t+    do  (v, t) <- inferExpr e 	v' <- {- etaContract =<< -} normalise v 	reify v' @@ -201,68 +159,62 @@ rewrite Normalised   t = {- etaContract =<< -} normalise t  -data OutputForm a b+data OutputForm a b = OutputForm ProblemId (OutputConstraint a b)+  deriving (Functor)++data OutputConstraint a b       = OfType b a | CmpInType Comparison a b b-                   | CmpTerms [Polarity] a [b] [b]+                   | CmpElim [Polarity] a [b] [b]       | JustType b | CmpTypes Comparison b b                    | CmpLevels Comparison b b                    | CmpTeles Comparison b b       | JustSort b | CmpSorts Comparison b b-      | Guard (OutputForm a b) [OutputForm a b]+      | Guard (OutputConstraint a b) ProblemId       | Assign b a | TypedAssign b a a-      | IsEmptyType a+      | IsEmptyType a | FindInScopeOF b+  deriving (Functor) --- | A subset of 'OutputForm'.+-- | A subset of 'OutputConstraint'. -data OutputForm' a b = OfType' { ofName :: b-                               , ofExpr :: a-                               }+data OutputConstraint' a b = OfType' { ofName :: b+                                     , ofExpr :: a+                                     }  outputFormId :: OutputForm a b -> b-outputFormId o = case o of-  OfType i _           -> i-  CmpInType _ _ i _    -> i-  CmpTerms _ _ (i:_) _ -> i-  CmpTerms _ _ [] _    -> __IMPOSSIBLE__-  JustType i           -> i-  CmpLevels _ i _      -> i-  CmpTypes _ i _       -> i-  CmpTeles _ i _       -> i-  JustSort i           -> i-  CmpSorts _ i _       -> i-  Guard o _            -> outputFormId o-  Assign i _           -> i-  TypedAssign i _ _    -> i-  IsEmptyType _        -> __IMPOSSIBLE__   -- Should never be used on IsEmpty constraints+outputFormId (OutputForm _ o) = out o+  where+    out o = case o of+      OfType i _           -> i+      CmpInType _ _ i _    -> i+      CmpElim _ _ (i:_) _  -> i+      CmpElim _ _ [] _     -> __IMPOSSIBLE__+      JustType i           -> i+      CmpLevels _ i _      -> i+      CmpTypes _ i _       -> i+      CmpTeles _ i _       -> i+      JustSort i           -> i+      CmpSorts _ i _       -> i+      Guard o _            -> out o+      Assign i _           -> i+      TypedAssign i _ _    -> i+      IsEmptyType _        -> __IMPOSSIBLE__   -- Should never be used on IsEmpty constraints+      FindInScopeOF _      -> __IMPOSSIBLE__ -instance Functor (OutputForm a) where-    fmap f (OfType e t)           = OfType (f e) t-    fmap f (JustType e)           = JustType (f e)-    fmap f (JustSort e)           = JustSort (f e)-    fmap f (CmpInType cmp t e e') = CmpInType cmp t (f e) (f e')-    fmap f (CmpTerms cmp t e e')  = CmpTerms cmp t (map f e) (map f e')-    fmap f (CmpTypes cmp e e')    = CmpTypes cmp (f e) (f e')-    fmap f (CmpLevels cmp e e')   = CmpLevels cmp (f e) (f e')-    fmap f (CmpTeles cmp e e')    = CmpTeles cmp (f e) (f e')-    fmap f (CmpSorts cmp e e')    = CmpSorts cmp (f e) (f e')-    fmap f (Guard o os)           = Guard (fmap f o) (fmap (fmap f) os)-    fmap f (Assign m e)           = Assign (f m) e-    fmap f (TypedAssign m e a)    = TypedAssign (f m) e a-    fmap f (IsEmptyType a)        = IsEmptyType a+instance Reify ProblemConstraint (Closure (OutputForm Expr Expr)) where+  reify (PConstr pid cl) = enterClosure cl $ \c -> buildClosure =<< (OutputForm pid <$> reify c) -instance Reify Constraint (OutputForm Expr Expr) where+instance Reify Constraint (OutputConstraint Expr Expr) where     reify (ValueCmp cmp t u v)   = CmpInType cmp <$> reify t <*> reify u <*> reify v-    reify (ArgsCmp cmp t u v)    = CmpTerms cmp <$> reify t-                                                <*> mapM (reify . unArg) u-                                                <*> mapM (reify . unArg) v+    reify (ElimCmp cmp t v es1 es2) =+      CmpElim cmp <$> reify t <*> reify es1+                              <*> reify es2     reify (LevelCmp cmp t t')    = CmpLevels cmp <$> reify t <*> reify t'     reify (TypeCmp cmp t t')     = CmpTypes cmp <$> reify t <*> reify t'-    reify (TelCmp  cmp t t')     = CmpTeles cmp <$> (ETel <$> reify t) <*> (ETel <$> reify t')+    reify (TelCmp a b cmp t t')  = CmpTeles cmp <$> (ETel <$> reify t) <*> (ETel <$> reify t')     reify (SortCmp cmp s s')     = CmpSorts cmp <$> reify s <*> reify s'-    reify (Guarded c cs) = do+    reify (Guarded c pid) = do 	o  <- reify c-	os <- mapM (withConstraint reify) cs-	return $ Guard o os+	return $ Guard o pid     reify (UnBlock m) = do         mi <- mvInstantiation <$> lookupMeta m         case mi of@@ -275,8 +227,12 @@             m' <- reify (MetaV m [])             return $ TypedAssign m' e a           Open{}  -> __IMPOSSIBLE__+          OpenIFS{}  -> __IMPOSSIBLE__           InstS{} -> __IMPOSSIBLE__           InstV{} -> __IMPOSSIBLE__+    reify (FindInScope m) = do+      m' <- reify (MetaV m [])+      return $ FindInScopeOF m' -- IFSTODO     reify (IsEmpty a) = IsEmptyType <$> reify a  showComparison :: Comparison -> String@@ -284,30 +240,39 @@ showComparison CmpLeq = " =< "  instance (Show a,Show b) => Show (OutputForm a b) where+  show (OutputForm 0   c) = show c+  show (OutputForm pid c) = "[" ++ show pid ++ "] " ++ show c++instance (Show a,Show b) => Show (OutputConstraint a b) where     show (OfType e t)           = show e ++ " : " ++ show t     show (JustType e)           = "Type " ++ show e     show (JustSort e)           = "Sort " ++ show e     show (CmpInType cmp t e e') = show e ++ showComparison cmp ++ show e' ++ " : " ++ show t-    show (CmpTerms cmp t e e')  = show e ++ "~~" ++ show e' ++ " : " ++ show t+    show (CmpElim cmp t e e')   = show e ++ " == " ++ show e' ++ " : " ++ show t     show (CmpTypes  cmp t t')   = show t ++ showComparison cmp ++ show t'     show (CmpLevels cmp t t')   = show t ++ showComparison cmp ++ show t'     show (CmpTeles  cmp t t')   = show t ++ showComparison cmp ++ show t'     show (CmpSorts cmp s s')    = show s ++ showComparison cmp ++ show s'-    show (Guard o os)           = show o ++ "  if  " ++ show os+    show (Guard o pid)          = show o ++ " [blocked by problem " ++ show pid ++ "]"     show (Assign m e)           = show m ++ " := " ++ show e-    show (TypedAssign m e a)    = show m ++ " := " ++ show e ++ " : " ++ show a+    show (TypedAssign m e a)    = show m ++ " := " ++ show e ++ " :? " ++ show a     show (IsEmptyType a)        = "Is empty: " ++ show a+    show (FindInScopeOF s)      = "Find in Scope: " ++ show s  instance (ToConcrete a c, ToConcrete b d) =>          ToConcrete (OutputForm a b) (OutputForm c d) where+    toConcrete (OutputForm pid c) = OutputForm pid <$> toConcrete c++instance (ToConcrete a c, ToConcrete b d) =>+         ToConcrete (OutputConstraint a b) (OutputConstraint c d) where     toConcrete (OfType e t) = OfType <$> toConcrete e <*> toConcreteCtx TopCtx t     toConcrete (JustType e) = JustType <$> toConcrete e     toConcrete (JustSort e) = JustSort <$> toConcrete e     toConcrete (CmpInType cmp t e e') =       CmpInType cmp <$> toConcreteCtx TopCtx t <*> toConcreteCtx ArgumentCtx e                                                <*> toConcreteCtx ArgumentCtx e'-    toConcrete (CmpTerms cmp t e e') =-      CmpTerms cmp <$> toConcreteCtx TopCtx t <*> mapM toConcrete e <*> mapM toConcrete e'+    toConcrete (CmpElim cmp t e e') =+      CmpElim cmp <$> toConcreteCtx TopCtx t <*> toConcreteCtx TopCtx e <*> toConcreteCtx TopCtx e'     toConcrete (CmpTypes cmp e e') = CmpTypes cmp <$> toConcreteCtx ArgumentCtx e                                                   <*> toConcreteCtx ArgumentCtx e'     toConcrete (CmpLevels cmp e e') = CmpLevels cmp <$> toConcreteCtx ArgumentCtx e@@ -315,17 +280,18 @@     toConcrete (CmpTeles cmp e e') = CmpTeles cmp <$> toConcrete e <*> toConcrete e'     toConcrete (CmpSorts cmp e e') = CmpSorts cmp <$> toConcreteCtx ArgumentCtx e                                                   <*> toConcreteCtx ArgumentCtx e'-    toConcrete (Guard o os) = Guard <$> toConcrete o <*> toConcrete os-    toConcrete (Assign m e) = Assign <$> toConcrete m <*> toConcreteCtx TopCtx e+    toConcrete (Guard o pid) = Guard <$> toConcrete o <*> pure pid+    toConcrete (Assign m e) = noTakenNames $ Assign <$> toConcrete m <*> toConcreteCtx TopCtx e     toConcrete (TypedAssign m e a) = TypedAssign <$> toConcrete m <*> toConcreteCtx TopCtx e                                                                   <*> toConcreteCtx TopCtx a     toConcrete (IsEmptyType a) = IsEmptyType <$> toConcreteCtx TopCtx a+    toConcrete (FindInScopeOF s) = FindInScopeOF <$> toConcrete s -instance (Pretty a, Pretty b) => Pretty (OutputForm' a b) where+instance (Pretty a, Pretty b) => Pretty (OutputConstraint' a b) where   pretty (OfType' e t) = pretty e <+> text ":" <+> pretty t  instance (ToConcrete a c, ToConcrete b d) =>-            ToConcrete (OutputForm' a b) (OutputForm' c d) where+            ToConcrete (OutputConstraint' a b) (OutputConstraint' c d) where   toConcrete (OfType' e t) = OfType' <$> toConcrete e <*> toConcreteCtx TopCtx t  --ToDo: Move somewhere else@@ -334,21 +300,16 @@ instance ToConcrete MetaId C.Expr where     toConcrete (MetaId i) = return $ C.Underscore noRange (Just i) -judgToOutputForm :: Judgement a c -> OutputForm a c+judgToOutputForm :: Judgement a c -> OutputConstraint a c judgToOutputForm (HasType e t) = OfType e t-judgToOutputForm (IsSort s)    = JustSort s----- Printing Operations-getConstraint :: Int -> TCM (OutputForm Expr Expr)-getConstraint ci =-    do  cc <- lookupConstraint ci-        cc <- reduce cc-        withConstraint reify cc-+judgToOutputForm (IsSort  s t) = JustSort s  getConstraints :: TCM [OutputForm C.Expr C.Expr] getConstraints = liftTCM $ do-    cs <- mapM (withConstraint (abstractToConcrete_ <.> reify)) =<< reduce =<< M.getConstraints+    cs <- M.getAllConstraints+    cs <- forM cs $ \c -> do+            cl <- reify c+            enterClosure cl abstractToConcrete_     ss <- mapM toOutputForm =<< getSolvedInteractionPoints     return $ ss ++ cs   where@@ -356,7 +317,7 @@       mv <- getMetaInfo <$> lookupMeta mi       withMetaInfo mv $ do         let m = QuestionMark $ MetaInfo noRange emptyScopeInfo (Just $ fromIntegral ii)-        abstractToConcrete_ $ Assign m e+        abstractToConcrete_ $ OutputForm 0 $ Assign m e  getSolvedInteractionPoints :: TCM [(InteractionId, MetaId, Expr)] getSolvedInteractionPoints = do@@ -373,12 +334,13 @@             unsol = return []         case mvInstantiation mv of           InstV{}                        -> sol (MetaV m args)-          InstS{}                        -> sol (Sort $ MetaS m args)+          InstS{}                        -> sol (Level $ Max [Plus 0 $ MetaLevel m args])           Open{}                         -> unsol+          OpenIFS{}                         -> unsol           BlockedConst{}                 -> unsol           PostponedTypeCheckingProblem{} -> unsol -typeOfMetaMI :: Rewrite -> MetaId -> TCM (OutputForm Expr MetaId)+typeOfMetaMI :: Rewrite -> MetaId -> TCM (OutputConstraint Expr MetaId) typeOfMetaMI norm mi =      do mv <- lookupMeta mi 	withMetaInfo (getMetaInfo mv) $@@ -396,20 +358,20 @@           ]         ]       OfType i <$> reify (t `piApply` permute (takeP (size vs) $ mvPermutation mv) vs)-    rewriteJudg mv (IsSort i) = return $ JustSort i+    rewriteJudg mv (IsSort i t) = return $ JustSort i  -typeOfMeta :: Rewrite -> InteractionId -> TCM (OutputForm Expr InteractionId)+typeOfMeta :: Rewrite -> InteractionId -> TCM (OutputConstraint Expr InteractionId) typeOfMeta norm ii =      do mi <- lookupInteractionId ii         out <- typeOfMetaMI norm mi         return $ fmap (\_ -> ii) out -typesOfVisibleMetas :: Rewrite -> TCM [OutputForm Expr InteractionId]+typesOfVisibleMetas :: Rewrite -> TCM [OutputConstraint Expr InteractionId] typesOfVisibleMetas norm =   liftTCM $ mapM (typeOfMeta norm) =<< getInteractionPoints -typesOfHiddenMetas :: Rewrite -> TCM [OutputForm Expr MetaId]+typesOfHiddenMetas :: Rewrite -> TCM [OutputConstraint Expr MetaId] typesOfHiddenMetas norm = liftTCM $ do   is    <- getInteractionMetas   store <- Map.filterWithKey (openAndImplicit is) <$> getMetaStore@@ -421,7 +383,7 @@  -- Gives a list of names and corresponding types. -contextOfMeta :: InteractionId -> Rewrite -> TCM [OutputForm' Expr Name]+contextOfMeta :: InteractionId -> Rewrite -> TCM [OutputConstraint' Expr Name] contextOfMeta ii norm = do   info <- getMetaInfo <$> (lookupMeta =<< lookupInteractionId ii)   let localVars = map ctxEntry . envContext . clEnv $ info@@ -437,10 +399,12 @@           return $ OfType x t'  -{-| Returns the type of the expression in the current environment -}+-- | Returns the type of the expression in the current environment+--   We wake up irrelevant variables just in case the user want to+--   invoke that command in an irrelevant context. typeInCurrent :: Rewrite -> Expr -> TCM Expr typeInCurrent norm e =-    do 	(_,t) <- inferExpr e+    do 	(_,t) <- wakeIrrelevantVars $ inferExpr e         v <- rewrite norm t         reify v @@ -538,7 +502,7 @@ -- of the top-level module.  atTopLevel :: TCM a -> TCM a-atTopLevel m = do+atTopLevel m = inConcreteMode $ do   mCurrent <- stCurrentModule <$> get   case mCurrent of     Nothing      -> typeError $@@ -548,10 +512,13 @@       case r of         Nothing -> __IMPOSSIBLE__         Just mi -> do+          let scope = iInsideScope $ miInterface mi           tel <- lookupSection current           M.withCurrentModule current $-            withScope_ (iInsideScope $ miInterface mi) $-              addCtxTel tel $+            withScope_ scope $+              addContext (zipWith' (fmap . (,))+                                   (map snd $ scopeLocals scope)+                                   (map (fmap snd) $ telToList tel)) $                 m  -- | Returns the contents of the given module.

src/full/Agda/Interaction/CommandLine/CommandLine.hs view

@@ -77,7 +77,7 @@ 		    Just _ -> 			do  go =<< liftTCM (eval $ fromJust ms) 	    `catchError` \e ->-		do  s <- prettyError e+		do  s <- liftTCM $ prettyError e 		    liftIO $ LocIO.putStrLn s 		    loop @@ -133,11 +133,6 @@ loadFile _ _ = liftIO $ LocIO.putStrLn ":load file"  showConstraints :: [String] -> TCM ()-showConstraints [c] =-    do	i  <- readM c-	cc <- normalise =<< lookupConstraint i-	d  <- prettyTCM $ clValue cc-	liftIO $ LocIO.print d showConstraints [] =     do	cs <- BasicOps.getConstraints 	liftIO $ LocIO.putStrLn $ unlines (List.map show cs)@@ -164,8 +159,8 @@         mapM_ (liftIO . LocIO.putStrLn) =<< mapM showII interactionMetas 	mapM_ print' hiddenMetas     where-	showII o = withInteractionId (outputFormId o) $ showA o-	showM  o = withMetaId (outputFormId o) $ showA o+	showII o = withInteractionId (outputFormId $ OutputForm 0 o) $ showA o+	showM  o = withMetaId (outputFormId $ OutputForm 0 o) $ showA o  	metaId (OfType i _) = i 	metaId (JustType i) = i@@ -222,7 +217,7 @@   retryConstraints :: TCM ()-retryConstraints = liftTCM wakeupConstraints+retryConstraints = liftTCM wakeupConstraints_   evalIn :: [String] -> TCM ()@@ -245,9 +240,8 @@ 	return Continue     where 	evalInCurrent e = do-	  t <- newTypeMeta_-	  v <- checkExpr e t-	  v' <- normalise v+	  (v,t) <- inferExpr e+	  v'    <- normalise v 	  return v'  @@ -261,7 +255,7 @@ typeIn :: [String] -> TCM () typeIn s@(_:_:_) =     actOnMeta s $ \i e ->-    do	e1  <- typeInMeta i Normalised e+    do	e1 <- typeInMeta i Normalised e         e2 <- typeInMeta i AsIs e 	liftIO . LocIO.putStrLn =<< showA e1 typeIn _ = liftIO $ LocIO.putStrLn ":typeIn meta expr"

+ src/full/Agda/Interaction/EmacsCommand.hs view

@@ -0,0 +1,45 @@+------------------------------------------------------------------------+-- | Low-level code for instructing Emacs to do things+------------------------------------------------------------------------++{-# LANGUAGE TypeSynonymInstances, FlexibleInstances #-}++module Agda.Interaction.EmacsCommand+  ( Lisp(..)+  , putResponse+  ) where++import qualified Agda.Utils.IO.Locale as LocIO+import Agda.Utils.Pretty++-- | Simple Emacs Lisp expressions.++data Lisp a+  = A a+    -- ^ Atom.+  | Cons (Lisp a) (Lisp a)+    -- Cons cell.+  | L [Lisp a]+    -- ^ List.+  | Q (Lisp a)+    -- Quoted expression.++instance Pretty a => Pretty (Lisp a) where+  pretty (A a )     = pretty a+  pretty (Cons a b) = parens (pretty a <+> text "." <+> pretty b)+  pretty (L xs)     = parens (hsep (map pretty xs))+  pretty (Q x)      = text "'" <> pretty x++instance Pretty String where pretty = text++instance Pretty a => Show (Lisp a) where show = show . pretty++-- | Formats a response command.++response :: Lisp String -> String+response l = show (text "agda2_mode_code" <+> pretty l)++-- | Writes a response command to standard output.++putResponse :: Lisp String -> IO ()+putResponse = LocIO.putStrLn . response

src/full/Agda/Interaction/GhciTop.hs view

@@ -1,4 +1,4 @@-{-# LANGUAGE CPP, TypeSynonymInstances #-}+{-# LANGUAGE CPP, TypeSynonymInstances, FlexibleInstances #-} {-# OPTIONS -fno-cse #-}  module Agda.Interaction.GhciTop@@ -42,7 +42,6 @@ import Agda.Utils.FileName import qualified Agda.Utils.Trie as Trie import Agda.Utils.Tuple-import qualified Agda.Utils.IO.Locale as LocIO import qualified Agda.Utils.IO.UTF8 as UTF8  import Control.Monad.Error@@ -63,8 +62,8 @@ import Agda.TypeChecking.MetaVars import Agda.TypeChecking.Reduce import Agda.TypeChecking.Errors-import Agda.TypeChecking.Serialise (encodeFile) +import Agda.Syntax.Fixity import Agda.Syntax.Position import Agda.Syntax.Parser import qualified Agda.Syntax.Parser.Tokens as T@@ -83,12 +82,12 @@ import Agda.Syntax.Translation.InternalToAbstract import Agda.Syntax.Abstract.Name +import Agda.Interaction.EmacsCommand import Agda.Interaction.Exceptions import Agda.Interaction.FindFile import Agda.Interaction.Options import Agda.Interaction.MakeCase import qualified Agda.Interaction.BasicOps as B-import qualified Agda.Interaction.CommandLine.CommandLine as CL import Agda.Interaction.Highlighting.Emacs import Agda.Interaction.Highlighting.Generate import qualified Agda.Interaction.Imports as Imp@@ -97,6 +96,7 @@  import qualified Agda.Compiler.Epic.Compiler as Epic import qualified Agda.Compiler.MAlonzo.Compiler as MAlonzo+import qualified Agda.Compiler.JS.Compiler as JS  import qualified Agda.Auto.Auto as Auto @@ -173,7 +173,7 @@     Left err -> do       Right doc <- runTCM $ prettyTCM err       putStrLn $ render doc-      return $ undefined+      return __IMPOSSIBLE__ {-   Right (x, s) <- runTCM $ do     put $ theTCState tcs@@ -205,9 +205,7 @@   current <- absolute current    -- Read the state.-  State { theTCState     = st-        , theCurrentFile = f-        } <- readIORef theState+  State { theTCState = st } <- readIORef theState    -- Run the computation.   r <- runTCM $ catchError (do@@ -227,20 +225,31 @@            st <- get            return (Right (x, st))          ) (\e -> do-           s <- prettyError e-           return (Left (s, e))+           pers <- stPersistent <$> get+           s    <- prettyError e+           return (Left (pers, s, e))          ) -  -- Update the state.+  -- Upon success: update the state. Upon failure: update the+  -- persistent state, and, for independent commands, the current+  -- file.   case r of     Right (Right (m, st')) ->       modifyIORef theState $ \s ->-        s { theTCState   = st'+        s { theTCState = st'           }-    _ | isIndependent cmd ->+    Right (Left (pers, _, _)) -> do       modifyIORef theState $ \s ->-        s { theCurrentFile = Nothing }-    _ -> return ()+        s { theTCState = (theTCState s) { stPersistent = pers }+          }+    Left _ -> return ()+  when (isIndependent cmd) $+    case r of+      Right (Right _) -> return ()+      _               ->+        modifyIORef theState $ \s ->+          s { theCurrentFile = Nothing+            }    -- Write out syntax highlighting info.   case highlightingFile of@@ -260,8 +269,8 @@               return ( iHighlighting $ miInterface mi                      , stModuleToSource st'                      )-            Right (Left (s, e)) -> errHi e (Just s)-            Left e              -> errHi e Nothing+            Right (Left (_ , s, e)) -> errHi e (Just s)+            Left e                  -> errHi e Nothing    -- If an error was encountered, display an error message and exit   -- with an error code; otherwise, inform Emacs about the buffer's@@ -271,15 +280,15 @@                              optShowImplicit $ stPragmaOptions st                          }   case r of-    Right (Left (s, e)) -> displayErrorAndExit errStatus (getRange e) s-    Left e              -> displayErrorAndExit errStatus (getRange e) $-                             tcErrString e-    Right (Right _)     -> do+    Right (Left (_, s, e)) -> displayErrorAndExit errStatus (getRange e) s+    Left e                 -> displayErrorAndExit errStatus (getRange e) $+                                tcErrString e+    Right (Right _)        -> do       f <- theCurrentFile <$> readIORef theState       case f of         Just (f, _) | f === current -> do           is <- theInteractionPoints <$> liftIO (readIORef theState)-          liftIO $ LocIO.putStrLn $ response $+          liftIO $ putResponse $             L [A "agda2-goals-action", Q $ L $ List.map showNumIId is]         _ -> return () @@ -315,7 +324,7 @@     -- All options (except for the verbosity setting) are reset when a     -- file is reloaded, including the choice of whether or not to     -- display implicit arguments. (At this point the include-    -- directories have already been reset, so they are preserved.)+    -- directories have already been set, so they are preserved.)     opts <- commandLineOptions     setCommandLineOptions $       defaultOptions { optIncludeDirs   = optIncludeDirs opts@@ -327,9 +336,9 @@                      }      -- Reset the state, preserving options and decoded modules. Note-    -- that Imp.typeCheck resets the decoded modules if the include-    -- directories have changed.-    preserveDecodedModules resetState+    -- that if the include directories have changed, then the decoded+    -- modules are reset when cmd_load' is run by ioTCM.+    resetState      ok <- Imp.typeCheck f @@ -352,7 +361,7 @@  -- | Available backends. -data Backend = MAlonzo | Epic+data Backend = MAlonzo | Epic | JS  -- | @cmd_compile b m includes@ compiles the module in file @m@ using -- the backend @b@, using @includes@ as the include directories.@@ -365,6 +374,7 @@         case b of           MAlonzo -> MAlonzo.compilerMain i           Epic    -> Epic.compilerMain i+          JS      -> JS.compilerMain i         display_info "*Compilation result*"                      "The module was successfully compiled."       Just w ->@@ -388,7 +398,7 @@   hms <- B.typesOfHiddenMetas B.Normalised   if not $ null ims && null hms     then do-      di <- mapM (\i -> B.withInteractionId (B.outputFormId i) (showATop i)) ims+      di <- mapM (\i -> B.withInteractionId (B.outputFormId $ B.OutputForm 0 i) (showATop i)) ims       dh <- mapM showA' hms       display_info "*All Goals*" $ unlines $ di ++ dh       return Nothing@@ -405,7 +415,7 @@     metaId _ = __IMPOSSIBLE__     showA' m = do       r <- getMetaRange (metaId m)-      d <- B.withMetaId (B.outputFormId m) (showATop m)+      d <- B.withMetaId (B.outputFormId $ B.OutputForm 0 m) (showATop m)       return $ d ++ "  [ at " ++ show r ++ " ]"  -- | If the range is 'noRange', then the string comes from the@@ -434,8 +444,7 @@   liftIO $ modifyIORef theState $ \s ->              s { theInteractionPoints =                    replace ii iis (theInteractionPoints s) }-  liftIO $ LocIO.putStrLn $ response $-             L [A "agda2-give-action", showNumIId ii, newtxt]+  liftIO $ putResponse $ L [A "agda2-give-action", showNumIId ii, newtxt]   command cmd_metas   return Nothing   where@@ -472,7 +481,7 @@     mapM_ (\(ii, s) -> do       liftIO $ modifyIORef theState $ \s ->         s { theInteractionPoints = filter (/= ii) (theInteractionPoints s) }-      liftIO $ LocIO.putStrLn $ response $ L [A "agda2-give-action", showNumIId ii, A $ quote s]+      liftIO $ putResponse $ L [A "agda2-give-action", showNumIId ii, A $ quote s]      ) xs     case msg of      Nothing -> command cmd_metas >> return ()@@ -482,7 +491,7 @@     case msg of      Nothing -> return ()      Just msg -> display_info "*Auto*" msg-    liftIO $ LocIO.putStrLn $ response $+    liftIO $ putResponse $      Cons (A "last")           (L [ A "agda2-make-case-action",                Q $ L $ List.map (A . quote) cs@@ -518,7 +527,7 @@   es  <- mapM (prettyATop . B.ofExpr) ctx   ns  <- mapM (showATop   . B.ofName) ctx   let shuffle = if rev then reverse else id-  return $ align 10 $ shuffle $ zip ns (map (text ":" <+>) es)+  return $ align 10 $ filter (not . null. fst) $ shuffle $ zip ns (map (text ":" <+>) es)  cmd_context :: B.Rewrite -> GoalCommand cmd_context norm ii _ _ = Interaction Dependent $ do@@ -655,15 +664,14 @@  displayStatus :: Status -> IO () displayStatus s =-  LocIO.putStrLn $ response $-    L [A "agda2-status-action", A (quote $ showStatus s)]+  putResponse $ L [A "agda2-status-action", A (quote $ showStatus s)]  -- | @display_info' header content@ displays @content@ (with header -- @header@) in some suitable way.  display_info' :: String -> String -> IO () display_info' bufname content =-  LocIO.putStrLn $ response $+  putResponse $     L [ A "agda2-info-action"       , A (quote bufname)       , A (quote content)@@ -683,23 +691,6 @@ display_infoD :: String -> Doc -> TCM () display_infoD bufname content = display_info bufname (render content) --- | Formats a response command.--response :: Lisp String -> String-response l = show (text "agda2_mode_code" <+> pretty l)--data Lisp a = A a | L [Lisp a] | Q (Lisp a) | Cons (Lisp a) (Lisp a)--instance Pretty a => Pretty (Lisp a) where-  pretty (A a )     = pretty a-  pretty (L xs)     = parens (sep (List.map pretty xs))-  pretty (Q x)      = text "'" <> pretty x-  pretty (Cons a b) = parens (pretty a <+> text "." <+> pretty b)--instance Pretty String where pretty = text--instance Pretty a => Show (Lisp a) where show = show . pretty- showNumIId = A . tail . show  takenNameStr :: TCM [String]@@ -722,21 +713,40 @@  cmd_make_case :: GoalCommand cmd_make_case ii rng s = Interaction Dependent $ do-  cs <- makeCase ii rng s+  (casectxt , cs) <- makeCase ii rng s   B.withInteractionId ii $ do-    pcs <- mapM prettyA cs-    liftIO $ LocIO.putStrLn $ response $+    hidden <- showImplicitArguments+    pcs <- mapM prettyA $ List.map (extlam_dropLLifted casectxt hidden) cs+    liftIO $ putResponse $       Cons (A "last")-           (L [ A "agda2-make-case-action"-              , Q $ L $ List.map (A . quote . render) pcs+           (L [ A (emacscmd casectxt)+              , Q $ L $ List.map (A . quote . (extlam_dropName casectxt) . render) pcs               ])   return Nothing-  where render = renderStyle (style { mode = OneLineMode })+  where+    render = renderStyle (style { mode = OneLineMode })+    emacscmd :: CaseContext -> String+    emacscmd FunctionDef = "agda2-make-case-action"+    emacscmd (ExtendedLambda _ _) = "agda2-make-case-action-extendlam" +    -- Drops pattern added to extended lambda functions when lambda lifting them+    extlam_dropLLifted :: CaseContext -> Bool -> SA.Clause -> SA.Clause+    extlam_dropLLifted FunctionDef _ x = x+    extlam_dropLLifted (ExtendedLambda h nh) hidden (SA.Clause (SA.LHS info name nps ps) rhs decl)+      = let n = if hidden then h else nh+        in+         (SA.Clause (SA.LHS info name (drop n nps) ps) rhs decl)++    -- very dirty hack, string manipulation by dropping the function name+    -- and replacing " = " with " -> "+    extlam_dropName :: CaseContext -> String -> String+    extlam_dropName FunctionDef x = x+    extlam_dropName (ExtendedLambda _ _) x = unwords $ map (\ y -> if y == "=" then "→" else y) $ drop 1 $ words x+ cmd_solveAll :: Interaction cmd_solveAll = Interaction Dependent $ do   out <- getInsts-  liftIO $ LocIO.putStrLn $ response $+  liftIO $ putResponse $     Cons (A "last")          (L [ A "agda2-solveAll-action"             , Q . L $ concatMap prn out@@ -747,7 +757,7 @@     where       lowr (i, m, e) = do         mi <- getMetaInfo <$> lookupMeta m-        e <- withMetaInfo mi $ lowerMeta <$> abstractToConcrete_ e+        e <- withMetaInfo mi $ lowerMeta <$> abstractToConcreteCtx TopCtx e         return (i, e)   prn (ii,e)= [showNumIId ii, A $ quote $ show e] @@ -766,6 +776,7 @@       SC.WithApp r e es	   -> SC.WithApp r (lowerMeta e) (lowerMeta es)       SC.Lam r bs e1       -> SC.Lam r (lowerMeta bs) (go e1)       SC.AbsurdLam r h     -> SC.AbsurdLam r h+      SC.ExtendedLam r cs  -> SC.ExtendedLam r cs       SC.Fun r ae1 e2      -> SC.Fun r (lowerMeta ae1) (go e2)       SC.Pi tb e1          -> SC.Pi (lowerMeta tb) (go e1)       SC.Set _             -> e@@ -782,12 +793,22 @@       SC.RawApp r es	-> SC.RawApp r (lowerMeta es)       SC.OpApp r x es	-> SC.OpApp r x (lowerMeta es)       SC.Rec r fs	-> SC.Rec r (List.map (id -*- lowerMeta) fs)+      SC.RecUpdate r e fs -> SC.RecUpdate r (lowerMeta e) (List.map (id -*- lowerMeta) fs)       SC.HiddenArg r e	-> SC.HiddenArg r (lowerMeta e)+      SC.InstanceArg r e  -> SC.InstanceArg r (lowerMeta e)       SC.QuoteGoal r x e  -> SC.QuoteGoal r x (lowerMeta e)-      SC.Quote r        -> SC.Quote r+      e@SC.Quote{}      -> e+      e@SC.QuoteTerm{}  -> e+      e@SC.Unquote{}    -> e+      SC.DontCare e     -> SC.DontCare (lowerMeta e) +instance LowerMeta (OpApp SC.Expr) where+  lowerMeta (Ordinary e) = Ordinary $ lowerMeta e+  lowerMeta (SyntaxBindingLambda r bs e) = SyntaxBindingLambda r (lowerMeta bs) (lowerMeta e)++ instance LowerMeta SC.LamBinding where-  lowerMeta b@(SC.DomainFree _ _) = b+  lowerMeta b@(SC.DomainFree _ _ _) = b   lowerMeta (SC.DomainFull tb)    = SC.DomainFull (lowerMeta tb)  instance LowerMeta SC.TypedBindings where@@ -801,19 +822,27 @@     lowerMeta (SC.RHS e)    = SC.RHS (lowerMeta e)     lowerMeta  SC.AbsurdRHS = SC.AbsurdRHS +instance LowerMeta (Maybe SC.Expr) where+    lowerMeta (Just e) = Just (lowerMeta e)+    lowerMeta Nothing  = Nothing+ instance LowerMeta SC.Declaration where   lowerMeta = go where     go d = case d of       TypeSig rel n e1              -> TypeSig rel n (lowerMeta e1)       SC.Field n e1                 -> SC.Field n (lowerMeta e1)       FunClause lhs rhs whcl        -> FunClause lhs (lowerMeta rhs) (lowerMeta whcl)+      SC.DataSig r ind n tel e1     -> SC.DataSig r ind n+                                         (lowerMeta tel) (lowerMeta e1)       Data r ind n tel e1 cs        -> Data r ind n                                          (lowerMeta tel) (lowerMeta e1) (lowerMeta cs)+      SC.RecordSig r n tel e1       -> SC.RecordSig r n+                                         (lowerMeta tel) (lowerMeta e1)       SC.Record r n c tel e1 cs     -> SC.Record r n c                                          (lowerMeta tel) (lowerMeta e1) (lowerMeta cs)       Infix _ _                     -> d       Syntax _ _                     -> d-      Mutual r ds                   -> Mutual r (lowerMeta ds)+      SC.Mutual r ds                -> SC.Mutual r (lowerMeta ds)       Abstract r ds                 -> Abstract r (lowerMeta ds)       Private r ds                  -> Private r (lowerMeta ds)       Postulate r sigs              -> Postulate r (lowerMeta sigs)@@ -821,10 +850,14 @@       SC.Open _ _ _                 -> d       SC.Import _ _ _ _ _           -> d       SC.Pragma _                   -> d-      ModuleMacro r n tel e1 op dir -> ModuleMacro r n-                                         (lowerMeta tel) (lowerMeta e1) op dir+      ModuleMacro r n modapp op dir -> ModuleMacro r n+                                         (lowerMeta modapp) op dir       SC.Module r qn tel ds         -> SC.Module r qn (lowerMeta tel) (lowerMeta ds) +instance LowerMeta SC.ModuleApplication where+  lowerMeta (SC.SectionApp r tel e) = SC.SectionApp r (lowerMeta tel) (lowerMeta e)+  lowerMeta (SC.RecordModuleIFS r rec) = SC.RecordModuleIFS r rec+ instance LowerMeta SC.WhereClause where   lowerMeta SC.NoWhere		= SC.NoWhere   lowerMeta (SC.AnyWhere ds)	= SC.AnyWhere $ lowerMeta ds@@ -944,7 +977,7 @@     Nothing                                    -> return ()     Just (Pn { srcFile = Nothing })            -> return ()     Just (Pn { srcFile = Just f, posPos = p }) ->-      LocIO.putStrLn $ response $+      putResponse $         L [ A "annotation-goto"           , Q $ L [A (quote $ filePath f), A ".", A (show p)]           ]

+ src/full/Agda/Interaction/Highlighting/Dot.hs view

@@ -0,0 +1,90 @@+{-# LANGUAGE CPP #-}+module Agda.Interaction.Highlighting.Dot where++import Control.Applicative+import Control.Monad.State++import qualified Data.Map as M+import Data.Map(Map)+import Data.Maybe+import Data.Monoid++import qualified Data.Set as S+import Data.Set (Set)++import System.Directory+import System.FilePath++import qualified Agda.Syntax.Concrete.Name as CN+import Agda.Interaction.FindFile+import Agda.Interaction.Options+import Agda.Syntax.Abstract+import Agda.Syntax.Abstract.Name+import Agda.TypeChecking.Monad++import Agda.Utils.FileName+++#include "../../undefined.h"+import Agda.Utils.Impossible++data DotState = DotState+  { dsModules    :: Map ModuleName String+  , dsNameSupply :: [String]+  , dsConnection :: Set (String, String)+  }++initialDotState :: DotState+initialDotState = DotState+  { dsModules    = mempty+  , dsNameSupply = map (('m':) . show) [0..]+  , dsConnection = mempty+  }++type DotM = StateT DotState TCM++addModule :: ModuleName -> DotM (String, Bool)+addModule m = do+    s <- get+    case M.lookup m (dsModules s) of+        Just r  -> return (r, False)+        Nothing -> do+            let newName:nameSupply = dsNameSupply s+            put s+              { dsModules = M.insert m newName (dsModules s)+              , dsNameSupply = nameSupply+              }+            return (newName, True)+++addConnection :: String -> String -> DotM ()+addConnection m1 m2 = modify $ \s -> s {dsConnection = S.insert (m1,m2) (dsConnection s)}++dottify :: Interface -> DotM String+dottify inter = do+    let curModule = iModuleName inter+    (name, continue) <- addModule curModule+    importsifs <- lift $ map miInterface . catMaybes <$> mapM (getVisitedModule . toTopLevelModuleName) (iImportedModules inter)+    when continue $ do+        imports    <- mapM dottify importsifs+        mapM_ (addConnection name) imports+    return name+++generateDot :: Interface -> TCM ()+generateDot inter = do+    (top, state) <- flip runStateT initialDotState $ do+        dottify inter+    mfile <- optDependencyGraph <$> commandLineOptions+    case mfile of+        Nothing -> __IMPOSSIBLE__+        Just fp -> liftIO $ writeFile fp $ mkDot state+  where+    mkDot :: DotState -> String+    mkDot st = unlines $+        [ "digraph dependencies {"+        ] ++ ["   " ++ repr ++ "[label=\"" ++ show modulename ++ "\"];"+             | (modulename, repr) <- M.toList (dsModules st)]+          ++ ["   " ++ r1 ++ " -> " ++ r2 ++ ";"+             | (r1 , r2) <- S.toList (dsConnection st) ]+          ++ ["}"]

src/full/Agda/Interaction/Highlighting/Emacs.hs view

@@ -10,7 +10,6 @@ import Agda.Interaction.FindFile import Agda.Interaction.Highlighting.Precise import Agda.Interaction.Highlighting.Range-import Agda.Interaction.Highlighting.Generate import Agda.Syntax.Abstract (QName) import Agda.Syntax.Common import qualified Agda.Syntax.Position as P

src/full/Agda/Interaction/Highlighting/Generate.hs view

@@ -37,7 +37,6 @@ import Control.Monad.State import Control.Applicative import Data.Monoid-import Data.Generics import Data.Function import Agda.Utils.Generics import Agda.Utils.FileName@@ -45,7 +44,7 @@ import qualified Data.Map as Map import Data.Maybe import Data.Sequence (Seq, (><))-import Data.List ((\\))+import Data.List ((\\), isPrefixOf) import qualified Data.Sequence as Seq import qualified Data.Foldable as Fold (toList, fold, foldMap) @@ -81,20 +80,17 @@ -- | Generates syntax highlighting information.  generateSyntaxInfo-  :: AbsolutePath           -- ^ The module to highlight.-  -> Maybe TCErr            -- ^ 'Nothing' if the module has been-                            --   successfully type checked (perhaps-                            --   with warnings), otherwise the-                            --   offending error.-                            ---                            --   Precondition: The range of the error-                            --   must match the file name given in the-                            --   previous argument.-  -> CA.TopLevelInfo        -- ^ The abstract syntax of the module.-  -> [([A.QName], [Range])] -- ^ Functions which failed to termination-                            --   check (grouped if they are mutual),-                            --   along with ranges for problematic-                            --   call sites.+  :: AbsolutePath          -- ^ The module to highlight.+  -> Maybe TCErr           -- ^ 'Nothing' if the module has been+                           --   successfully type checked (perhaps+                           --   with warnings), otherwise the+                           --   offending error.+                           --+                           --   Precondition: The range of the error+                           --   must match the file name given in the+                           --   previous argument.+  -> CA.TopLevelInfo       -- ^ The abstract syntax of the module.+  -> [M.TerminationError]  -- ^ Termination checking problems.   -> TCM HighlightingInfo generateSyntaxInfo file mErr top termErrs = do   reportSLn "import.iface.create" 15  $@@ -151,7 +147,6 @@       tokenToFile (T.TokKeyword T.KwForall i)      = aToF Symbol (P.getRange i)       tokenToFile (T.TokKeyword _ i)               = aToF Keyword (P.getRange i)       tokenToFile (T.TokSymbol  _ i)               = aToF Symbol (P.getRange i)-      tokenToFile (T.TokLiteral (L.LitLevel  r _)) = aToF Number r       tokenToFile (T.TokLiteral (L.LitInt    r _)) = aToF Number r       tokenToFile (T.TokLiteral (L.LitFloat  r _)) = aToF Number r       tokenToFile (T.TokLiteral (L.LitString r _)) = aToF String r@@ -169,9 +164,9 @@       where       m            = mempty { otherAspects = [TerminationProblem] }       functionDefs = Fold.foldMap (\x -> several (rToR $ bindingSite x) m) $-                     concatMap fst termErrs-      callSites    = Fold.foldMap (\r -> singleton r m) $-                     concatMap snd termErrs+                     concatMap M.termErrFunctions termErrs+      callSites    = Fold.foldMap (\r -> several (rToR r) m) $+                     concatMap (map M.callInfoRange . M.termErrCalls) termErrs      -- All names mentioned in the syntax tree (not bound variables).     names = everything' (><) (Seq.empty `mkQ`  getName@@ -179,8 +174,10 @@                         decls       where       getName :: A.QName -> Seq A.AmbiguousQName-      getName n = Seq.singleton (A.AmbQ [n])+      getName n | isPrefixOf extendlambdaname $ show $ A.qnameName n = mempty+                | otherwise                                          = Seq.singleton (A.AmbQ [n]) +       getAmbiguous :: A.AmbiguousQName -> Seq A.AmbiguousQName       getAmbiguous = Seq.singleton @@ -228,7 +225,7 @@       getLet A.LetOpen{}           = mempty        getLam :: A.LamBinding -> File-      getLam (A.DomainFree _ x) = bound x+      getLam (A.DomainFree _ _ x) = bound x       getLam (A.DomainFull {})  = mempty        getTyped :: A.TypedBinding -> File@@ -243,7 +240,7 @@                 (mempty { otherAspects = [DottedPattern] })       getPattern _             = mempty -      getFieldDecl :: A.Definition -> File+      getFieldDecl :: A.Declaration -> File       getFieldDecl (A.RecDef _ _ _ _ _ fs) = Fold.foldMap extractField fs         where         extractField (A.ScopedDecl _ ds) = Fold.foldMap extractField ds@@ -288,7 +285,7 @@     Just _  -> return $       -- Traverses the syntax tree and constructs a map from qualified       -- names to name kinds. TODO: Handle open public.-      everything' union (Map.empty `mkQ` getDef `extQ` getDecl) decls+      everything' union (Map.empty `mkQ` getDecl) decls   let merged = Map.union local imported   return (\n -> Map.lookup n merged)   where@@ -305,43 +302,43 @@     dropPostulates k         _ = k    defnToNameKind :: Defn -> NameKind-  defnToNameKind (M.Axiom {})                               = Postulate-  defnToNameKind (M.Function { M.funProjection = Nothing }) = Function-  defnToNameKind (M.Function { M.funProjection = Just _  }) = Field-  defnToNameKind (M.Datatype {})                            = Datatype-  defnToNameKind (M.Record {})                              = Record-  defnToNameKind (M.Constructor { M.conInd = i })           = Constructor i-  defnToNameKind (M.Primitive {})                           = Primitive+  defnToNameKind (M.Axiom {})                     = Postulate+  defnToNameKind (M.Function {})                  = Function+  defnToNameKind (M.Datatype {})                  = Datatype+  defnToNameKind (M.Record {})                    = Record+  defnToNameKind (M.Constructor { M.conInd = i }) = Constructor i+  defnToNameKind (M.Primitive {})                 = Primitive    getAxiomName :: A.Declaration -> A.QName   getAxiomName (A.Axiom _ _ q _) = q   getAxiomName _                 = __IMPOSSIBLE__ -  getDef :: A.Definition -> Map A.QName NameKind-  getDef (A.FunDef  _ q _)       = Map.singleton q Function-  getDef (A.DataDef _ q _ cs)    = Map.singleton q Datatype `union`-                                   (Map.unions $-                                    map (\q -> Map.singleton q (Constructor SC.Inductive)) $-                                    map getAxiomName cs)-  getDef (A.RecDef  _ q c _ _ _) = Map.singleton q Record `union`-                                   case c of-                                     Nothing -> Map.empty-                                     Just (A.Axiom _ _ q _) ->-                                       Map.singleton q (Constructor SC.Inductive)-                                     Just _ -> __IMPOSSIBLE__-  getDef (A.ScopedDef {})        = Map.empty-   getDecl :: A.Declaration -> Map A.QName NameKind   getDecl (A.Axiom _ _ q _)   = Map.singleton q Postulate-  getDecl (A.Field _ q _)     = Map.singleton q Field+  getDecl (A.Field _ q _)     = Map.singleton q Function+    -- Note that the name q can be used both as a field name and as a+    -- projection function. Highlighting of field names is taken care+    -- of by "theRest" above, which does not use NameKinds.   getDecl (A.Primitive _ q _) = Map.singleton q Primitive-  getDecl (A.Definition {})   = Map.empty+  getDecl (A.Mutual {})       = Map.empty   getDecl (A.Section {})      = Map.empty   getDecl (A.Apply {})        = Map.empty   getDecl (A.Import {})       = Map.empty   getDecl (A.Pragma {})       = Map.empty   getDecl (A.ScopedDecl {})   = Map.empty   getDecl (A.Open {})         = Map.empty+  getDecl (A.FunDef  _ q _)       = Map.singleton q Function+  getDecl (A.DataSig _ q _ _)       = Map.singleton q Datatype+  getDecl (A.DataDef _ q _ cs)    = Map.singleton q Datatype `union`+                                   (Map.unions $+                                    map (\q -> Map.singleton q (Constructor SC.Inductive)) $+                                    map getAxiomName cs)+  getDecl (A.RecSig _ q _ _)      = Map.singleton q Record+  getDecl (A.RecDef _ q c _ _ _)  = Map.singleton q Record `union`+                                   case c of+                                     Nothing -> Map.empty+                                     Just q ->+                                       Map.singleton q (Constructor SC.Inductive)  -- | Generates syntax highlighting information for all constructors -- occurring in patterns and expressions in the given declarations.@@ -401,11 +398,10 @@       NotDelayed -> return Seq.empty        Delayed -> do-        clauses <- R.instantiateFull $ map I.originalClause $-                     defClauses def+        clauses <- R.instantiateFull $ defClauses def         case clauses of           [I.Clause{ I.clauseBody = body }] -> case getRHS body of-            Just (I.Def c args) -> do+            Just (I.Con c args) -> do               s <- everything' (liftM2 (><)) query args               return $ Seq.singleton c >< s @@ -418,8 +414,7 @@     where       getRHS (I.Body v)   = Just v       getRHS I.NoBody     = Nothing-      getRHS (I.Bind b)   = getRHS (I.absBody b)-      getRHS (I.NoBind b) = getRHS b+      getRHS (I.Bind b)   = getRHS (I.unAbs b)  -- | Generates syntax highlighting information for unsolved meta -- variables.

src/full/Agda/Interaction/Imports.hs view

@@ -6,6 +6,7 @@  import Prelude hiding (catch) +import Control.Arrow import Control.Monad.Error import Control.Monad.State import qualified Control.Exception as E@@ -52,6 +53,7 @@ import Agda.Utils.Monad import Agda.Utils.IO.Binary import Agda.Utils.Pretty+import Agda.Utils.Fresh  import Agda.Utils.Impossible #include "../undefined.h"@@ -63,7 +65,7 @@ 	builtin = Map.toList $ iBuiltin i 	prim	= [ x | (_,Prim x) <- builtin ] 	bi	= Map.fromList [ (x,Builtin t) | (x,Builtin t) <- builtin ]-    bs <- getBuiltinThings+    bs <- gets stBuiltinThings     reportSLn "import.iface.merge" 10 $ "Merging interface"     reportSLn "import.iface.merge" 20 $       "  Current builtins " ++ show (Map.keys bs) ++ "\n" ++@@ -152,7 +154,7 @@ -- Invariant: The fields are never empty at the same time.  data Warnings = Warnings-  { terminationProblems   :: [([QName], [R.Range])]+  { terminationProblems   :: [TerminationError]     -- ^ Termination checking problems are not reported if     -- 'optTerminationCheck' is 'False'.   , unsolvedMetaVariables :: [Range]@@ -208,7 +210,7 @@   bracket (stPragmaOptions <$> get)           (unless includeStateChanges . setPragmaOptions) $ \_ -> do    -- Forget the pragma options (locally).-   setCommandLineOptions . stPersistentOptions =<< get+   setCommandLineOptions . stPersistentOptions . stPersistent =<< get     alreadyVisited x $ addImportCycleCheck x $ do     file <- findFile x  -- requires source to exist@@ -330,10 +332,12 @@             mf       <- stModuleToSource <$> get             vs       <- getVisitedModules             ds       <- getDecodedModules-            opts     <- stPersistentOptions <$> get+            opts     <- stPersistentOptions . stPersistent <$> get             isig     <- getImportedSignature             ibuiltin <- gets stImportedBuiltins-            -- Every interface is treated in isolation.+            -- Every interface is treated in isolation. Note: Changes+            -- to stDecodedModules are not preserved if an error is+            -- encountered in an imported module.             r <- liftIO $ runTCM $                    withImportPath ms $ do                      setDecodedModules ds@@ -398,9 +402,9 @@  writeInterface :: FilePath -> Interface -> TCM ClockTime writeInterface file i = do-    reportSLn "import.iface.write" 5  $-      "Writing interface file " ++ file ++ "."+    reportSLn "import.iface.write" 5  $ "Writing interface file " ++ file ++ "."     encodeFile file i+    reportSLn "import.iface.write" 5 "Wrote interface file."     liftIO $ getModificationTime file   `catchError` \e -> do     reportSLn "" 1 $@@ -443,14 +447,20 @@     termErrs <- catchError (do       -- Type checking.       checkDecls (topLevelDecls topLevel)+      unfreezeMetas +      -- Count number of metas+      verboseS "profile.metas" 10 $ do+        MetaId n <- fresh+        tickN "metas" n+       -- Termination checking.       termErrs <- ifM (optTerminationCheck <$> pragmaOptions)                       (termDecls $ topLevelDecls topLevel)                       (return [])       mapM_ (\e -> reportSLn "term.warn.no" 2-                     (show (fst e) ++-                      " does NOT pass the termination checker."))+                     (show (termErrFunctions e) +++                      " do(es) NOT pass the termination checker."))             termErrs       return termErrs       ) (\e -> do@@ -476,6 +486,15 @@     whenM (optGenerateVimFile <$> commandLineOptions) $ 	withScope_ (insideScope topLevel) $ generateVimFile $ filePath file +    -- Print stats+    stats <- Map.toList <$> getStatistics+    case stats of+      []      -> return ()+      _       -> reportS "profile" 1 $ unlines $+        [ "Ticks for " ++ show (pretty mname) ] +++        [ "  " ++ s ++ " = " ++ show n+        | (s, n) <- sortBy (compare `on` snd) stats ]+     -- Check if there are unsolved meta-variables...     unsolvedOK    <- optAllowUnsolved <$> pragmaOptions     unsolvedMetas <- List.nub <$> (mapM getMetaRange =<< getOpenMetas)@@ -483,7 +502,7 @@       typeError $ UnsolvedMetas unsolvedMetas      -- ...or unsolved constraints-    unsolvedConstraints <- getConstraints+    unsolvedConstraints <- getAllConstraints     unless (null unsolvedConstraints || unsolvedOK) $       typeError $ UnsolvedConstraints unsolvedConstraints

src/full/Agda/Interaction/Imports.hs-boot view

@@ -7,4 +7,3 @@ import Data.Map                     ( Map )  scopeCheckImport :: ModuleName -> TCM (ModuleName, Map ModuleName Scope)-

src/full/Agda/Interaction/MakeCase.hs view

@@ -24,6 +24,8 @@ import Agda.TypeChecking.Coverage import Agda.TypeChecking.Pretty import Agda.TypeChecking.Reduce+import Agda.TypeChecking.Substitute+import Agda.TypeChecking.Irrelevance import Agda.TypeChecker  import Agda.Interaction.BasicOps@@ -34,6 +36,8 @@ #include "../undefined.h" import Agda.Utils.Impossible +data CaseContext = FunctionDef | ExtendedLambda Int Int+                 deriving (Eq) -- | Find the clause whose right hand side is the given meta -- BY SEARCHING THE WHOLE SIGNATURE. Returns -- the original clause, before record patterns have been translated@@ -44,13 +48,13 @@ -- thrown away earlier.  (shutter with disgust). -- This code fails for record rhs because they have been eta-expanded, -- so the MVar is gone.-findClause :: MetaId -> TCM (QName, Clause)+findClause :: MetaId -> TCM (CaseContext, QName, Clause) findClause m = do   sig <- getImportedSignature   let res = do         def <- Map.elems $ sigDefinitions sig         Function{funClauses = cs} <- [theDef def]-        c <- map originalClause cs+        c <- cs         unless (rhsIsm $ clauseBody c) []         return (defName def, c)   case res of@@ -62,24 +66,27 @@         ]       reportSDoc "interaction.case" 20 $ vcat $ map (text . show) (Map.elems $ sigDefinitions sig)  -- you asked for it!       typeError $ GenericError "Right hand side must be a single hole when making a case distinction."-    [r] -> return r+    [(n,c)] | isPrefixOf extendlambdaname $ show $ A.qnameName n -> do+                                               Just (h , nh) <- Map.lookup n <$> getExtLambdaTele+                                               return (ExtendedLambda h nh , n , c)+            | otherwise                                          -> return (FunctionDef , n , c)     _   -> __IMPOSSIBLE__   where-    rhsIsm (Bind b)   = rhsIsm $ absBody b-    rhsIsm (NoBind b) = rhsIsm b+    rhsIsm (Bind b)   = rhsIsm $ unAbs b     rhsIsm NoBody     = False     rhsIsm (Body e)   = case e of       MetaV m' _  -> m == m'       _           -> False -makeCase :: InteractionId -> Range -> String -> TCM [A.Clause]+makeCase :: InteractionId -> Range -> String -> TCM (CaseContext , [A.Clause]) makeCase hole rng s = withInteractionId hole $ do   meta        <- lookupInteractionId hole-  (f, clause@(Clause{ clauseTel = tel, clausePerm = perm, clausePats = ps })) <- findClause meta+  (casectxt, f, clause@(Clause{ clauseTel = tel, clausePerm = perm, clausePats = ps })) <- findClause meta   reportSDoc "interaction.case" 10 $ vcat     [ text "splitting clause:"     , nest 2 $ vcat-      [ text "context =" <+> (prettyTCM =<< getContextTelescope)+      [ text "f       =" <+> prettyTCM f+      , text "context =" <+> (prettyTCM =<< getContextTelescope)       , text "tel     =" <+> prettyTCM tel       , text "perm    =" <+> text (show perm)       , text "ps      =" <+> text (show ps)@@ -87,10 +94,10 @@     ]   var         <- deBruijnIndex =<< parseExprIn hole rng s   z           <- splitClauseWithAbs clause var-  case z of+  (case z of     Left err        -> typeError . GenericError . show =<< prettyTCM err-    Right (Left cl) -> (:[]) <$> makeAbsurdClause f cl-    Right (Right c) -> mapM (makeAbstractClause f) c+    Right (Left cl) -> ((:[]) <$> makeAbsurdClause f cl)+    Right (Right c) -> (mapM (makeAbstractClause f) c)) >>= (\ x -> return (casectxt , x))  makeAbsurdClause :: QName -> SplitClause -> TCM A.Clause makeAbsurdClause f (SClause tel perm ps _) = do@@ -121,7 +128,8 @@ deBruijnIndex :: A.Expr -> TCM Nat deBruijnIndex e = do   (v, _) <- -- Andreas, 2010-09-21 allow splitting on irrelevant (record) vars-            Context.wakeIrrelevantVars $+--            Context.wakeIrrelevantVars $+            applyRelevanceToContext Irrelevant $               inferExpr e   case v of     Var n _ -> return n

src/full/Agda/Interaction/Monad.hs view

@@ -1,4 +1,5 @@-{-# LANGUAGE TypeSynonymInstances, MultiParamTypeClasses #-}+{-# LANGUAGE TypeSynonymInstances, FlexibleInstances,+             MultiParamTypeClasses #-} module Agda.Interaction.Monad where  import Agda.TypeChecking.Monad

src/full/Agda/Interaction/Options.hs view

@@ -1,3 +1,5 @@+{-# LANGUAGE StandaloneDeriving, DeriveFunctor #-}+ module Agda.Interaction.Options     ( CommandLineOptions(..)     , PragmaOptions(..)@@ -11,6 +13,7 @@     , defaultOptions     , defaultVerbosity     , standardOptions_+    , unsafePragmaOptions     , isLiterate     , mapFlag     , usage@@ -19,7 +22,8 @@  import Control.Monad            ( when ) import Control.Monad.Error	( MonadError(..) )-import Data.List		( isSuffixOf )+import Data.Maybe (isJust)+import Data.List		( isSuffixOf , intercalate ) import System.Console.GetOpt	(getOpt, usageInfo, ArgOrder(ReturnInOrder) 				, OptDescr(..), ArgDescr(..) 				)@@ -38,13 +42,8 @@  -- OptDescr is a Functor -------------------------------------------------- -instance Functor OptDescr where-    fmap f (Option short long arg descr) = Option short long (fmap f arg) descr--instance Functor ArgDescr where-    fmap f (NoArg x)	= NoArg (f x)-    fmap f (ReqArg p s) = ReqArg (f . p) s-    fmap f (OptArg p s) = OptArg (f . p) s+deriving instance Functor OptDescr+deriving instance Functor ArgDescr  type Verbosity = Trie String Int @@ -62,10 +61,12 @@ 	    , optRunTests             :: Bool 	    , optCompile              :: Bool 	    , optEpicCompile          :: Bool+	    , optJSCompile            :: Bool             , optCompileDir           :: Maybe FilePath               -- ^ In the absence of a path the project root is used. 	    , optGenerateVimFile      :: Bool 	    , optGenerateHTML         :: Bool+	    , optDependencyGraph      :: Maybe FilePath 	    , optHTMLDir              :: FilePath 	    , optCSSFile              :: Maybe FilePath 	    , optIgnoreInterfaces     :: Bool@@ -73,7 +74,8 @@             , optGhcFlags             :: [String]             , optPragmaOptions        :: PragmaOptions             , optEpicFlags            :: [String]-	    }+            , optSafe                 :: Bool+            }     deriving Show  -- | Options which can be set in a pragma.@@ -87,13 +89,13 @@   , optTerminationCheck          :: Bool   , optTerminationDepth          :: Int   , optCompletenessCheck         :: Bool-  , optUnreachableCheck          :: Bool   , optUniverseCheck             :: Bool   , optSizedTypes                :: Bool   , optInjectiveTypeConstructors :: Bool   , optGuardingTypeConstructors  :: Bool   , optUniversePolymorphism      :: Bool   , optIrrelevantProjections     :: Bool+  , optExperimentalIrrelevance   :: Bool  -- ^ irrelevant levels, irrelevant data matching   , optWithoutK                  :: Bool   }   deriving Show@@ -124,9 +126,11 @@ 	    , optRunTests             = False 	    , optCompile              = False 	    , optEpicCompile          = False+	    , optJSCompile            = False             , optCompileDir           = Nothing 	    , optGenerateVimFile      = False 	    , optGenerateHTML         = False+	    , optDependencyGraph      = Nothing 	    , optHTMLDir              = defaultHTMLDir 	    , optCSSFile              = Nothing 	    , optIgnoreInterfaces     = False@@ -134,6 +138,7 @@             , optGhcFlags             = []             , optPragmaOptions        = defaultPragmaOptions             , optEpicFlags            = []+            , optSafe                 = False 	    }  defaultPragmaOptions :: PragmaOptions@@ -141,18 +146,18 @@   { optShowImplicit              = False   , optVerbose                   = defaultVerbosity   , optProofIrrelevance          = False+  , optExperimentalIrrelevance   = False   , optIrrelevantProjections     = True   , optAllowUnsolved             = False   , optDisablePositivity         = False   , optTerminationCheck          = True   , optTerminationDepth          = 0    -- this is the cutoff value   , optCompletenessCheck         = True-  , optUnreachableCheck          = True   , optUniverseCheck             = True   , optSizedTypes                = False   , optInjectiveTypeConstructors = False   , optGuardingTypeConstructors  = False-  , optUniversePolymorphism      = False+  , optUniversePolymorphism      = True   , optWithoutK                  = False   } @@ -176,10 +181,12 @@ checkOpts opts   | not (atMostOne [optAllowUnsolved . p, optCompile]) = Left       "Unsolved meta variables are not allowed when compiling.\n"-  | not (atMostOne [optInteractive, optCompile, optEpicCompile]) =+  | not (atMostOne [optInteractive, optCompile, optEpicCompile, optJSCompile]) =       Left "Choose at most one: compiler/interactive mode.\n"   | not (atMostOne [optGenerateHTML, optInteractive]) =       Left "Choose at most one: HTML generator or interactive mode.\n"+  | not (atMostOne [isJust . optDependencyGraph, optInteractive]) =+      Left "Choose at most one: Dependency graph generator or interactive mode.\n"   | not (atMostOne [ optUniversePolymorphism . p                    , not . optUniverseCheck . p                    ]) =@@ -193,6 +200,30 @@    p = optPragmaOptions +-- Check for unsafe pramas. Gives a list of used unsafe flags.++unsafePragmaOptions :: PragmaOptions -> [String]+unsafePragmaOptions opts =+  [ "--allow-unsolved-metas"                     | optAllowUnsolved opts             ] +++  [ "--no-positivity-check"                      | optDisablePositivity opts         ] +++  [ "--no-termination-check"                     | not (optTerminationCheck opts)    ] +++  [ "--no-coverage-check"                        | not (optCompletenessCheck opts)   ] +++  [ "--type-in-type"                             | not (optUniverseCheck opts)       ] +++  [ "--sized-types"                              | optSizedTypes opts                ] +++  [ "--injective-type-constructors"              | optInjectiveTypeConstructors opts ] +++  [ "--guardedness-preserving-type-constructors" | optGuardingTypeConstructors opts  ] +++  [ "--experimental-irrelevance"                 | optExperimentalIrrelevance opts   ]++-- The default pragma options should be considered safe++defaultPragmaOptionsSafe :: IO Bool+defaultPragmaOptionsSafe+    | null unsafe = return True+    | otherwise   = do putStrLn $ "Following pragmas are default but not safe: "+                                  ++ intercalate ", " unsafe+                       return False+  where unsafe = unsafePragmaOptions defaultPragmaOptions+ inputFlag :: FilePath -> Flag CommandLineOptions inputFlag f o =     case optInputFile o of@@ -201,7 +232,9 @@  versionFlag                  o = return $ o { optShowVersion               = True  } helpFlag                     o = return $ o { optShowHelp                  = True  }+safeFlag                     o = return $ o { optSafe                      = True  } proofIrrelevanceFlag         o = return $ o { optProofIrrelevance          = True  }+experimentalIrrelevanceFlag  o = return $ o { optExperimentalIrrelevance   = True  } noIrrelevantProjectionsFlag  o = return $ o { optIrrelevantProjections     = False } ignoreInterfacesFlag         o = return $ o { optIgnoreInterfaces          = True  } allowUnsolvedFlag            o = return $ o { optAllowUnsolved             = True  }@@ -211,12 +244,13 @@ noPositivityFlag             o = return $ o { optDisablePositivity         = True  } dontTerminationCheckFlag     o = return $ o { optTerminationCheck          = False } dontCompletenessCheckFlag    o = return $ o { optCompletenessCheck         = False }-noUnreachableCheckFlag       o = return $ o { optUnreachableCheck          = False }-dontUniverseCheckFlag        o = return $ o { optUniverseCheck             = False }+dontUniverseCheckFlag        o = return $ o { optUniverseCheck             = False+                                            , optUniversePolymorphism      = False } sizedTypes                   o = return $ o { optSizedTypes                = True  } injectiveTypeConstructorFlag o = return $ o { optInjectiveTypeConstructors = True  } guardingTypeConstructorFlag  o = return $ o { optGuardingTypeConstructors  = True  } universePolymorphismFlag     o = return $ o { optUniversePolymorphism      = True  }+noUniversePolymorphismFlag   o = return $ o { optUniversePolymorphism      = False } noForcingFlag                o = return $ o { optForcing                   = False } withoutKFlag                 o = return $ o { optWithoutK                  = True  } @@ -226,11 +260,13 @@ 		                } compileFlag      o = return $ o { optCompile    = True } compileEpicFlag  o = return $ o { optEpicCompile = True}+compileJSFlag    o = return $ o { optJSCompile = True} compileDirFlag f o = return $ o { optCompileDir = Just f } ghcFlag        f o = return $ o { optGhcFlags   = f : optGhcFlags o } epicFlagsFlag  s o = return $ o { optEpicFlags  = optEpicFlags o ++ [s]}  htmlFlag      o = return $ o { optGenerateHTML = True }+dependencyGraphFlag f o = return $ o { optDependencyGraph  = Just f } htmlDirFlag d o = return $ o { optHTMLDir      = d } cssFlag     f o = return $ o { optCSSFile      = Just f } @@ -268,6 +304,7 @@     , Option ['c']  ["compile"] (NoArg compileFlag)                     "compile program using the MAlonzo backend (experimental)"     , Option []     ["epic"] (NoArg compileEpicFlag) "compile program using the Epic backend"+    , Option []     ["js"] (NoArg compileJSFlag) "compile program using the JS backend"     , Option []     ["compile-dir"] (ReqArg compileDirFlag "DIR") 		    ("directory for compiler output (default: the project root)")     , Option []     ["ghc-flag"] (ReqArg ghcFlag "GHC-FLAG")@@ -280,6 +317,8 @@ 		    "generate Vim highlighting files"     , Option []	    ["html"] (NoArg htmlFlag) 		    "generate HTML files with highlighted source code"+    , Option []	    ["dependency-graph"] (ReqArg dependencyGraphFlag "FILE")+		    "generate a Dot file with a module dependency graph"     , Option []	    ["html-dir"] (ReqArg htmlDirFlag "DIR")                     ("directory in which HTML files are placed (default: " ++                      defaultHTMLDir ++ ")")@@ -291,6 +330,8 @@ 		    "look for imports in DIR"     , Option []     ["no-forcing"] (NoArg noForcingFlag)                     "disable the forcing optimisation"+    , Option []     ["safe"] (NoArg safeFlag)+                    "disable postulates, unsafe OPTION pragmas and primTrustMe"     ] ++ map (fmap lift) pragmaOptions   where   lift :: Flag PragmaOptions -> Flag CommandLineOptions@@ -316,20 +357,22 @@ 		    "allow termination checker to count decrease/increase upto N (default N=1)"     , Option []	    ["no-coverage-check"] (NoArg dontCompletenessCheckFlag) 		    "do not warn about possibly incomplete pattern matches"-    , Option []	    ["no-unreachable-check"] (NoArg noUnreachableCheckFlag)-		    "do not warn about unreachable function clauses"     , Option []	    ["type-in-type"] (NoArg dontUniverseCheckFlag) 		    "ignore universe levels (this makes Agda inconsistent)"     , Option []     ["sized-types"] (NoArg sizedTypes)-                    "use sized datatypes"+                    "use sized types (inconsistent with coinduction)"     , Option []     ["injective-type-constructors"] (NoArg injectiveTypeConstructorFlag)                     "enable injective type constructors (makes Agda anti-classical and possibly inconsistent)"     , Option []     ["guardedness-preserving-type-constructors"] (NoArg guardingTypeConstructorFlag)                     "treat type constructors as inductive constructors when checking productivity"+    , Option []     ["no-universe-polymorphism"] (NoArg noUniversePolymorphismFlag)+                    "disable universe polymorphism"     , Option []     ["universe-polymorphism"] (NoArg universePolymorphismFlag)-                    "enable universe polymorphism (experimental feature)"+                    "enable universe polymorphism (default)"     , Option []     ["no-irrelevant-projections"] (NoArg noIrrelevantProjectionsFlag)                     "disable projection of irrelevant record fields"+    , Option []     ["experimental-irrelevance"] (NoArg experimentalIrrelevanceFlag)+                    "enable potentially unsound irrelevance features (irrelevant levels, irrelevant data matching)"     , Option []     ["without-K"] (NoArg withoutKFlag)                     "disable the K rule (maybe)"     ]@@ -405,4 +448,5 @@ tests :: IO Bool tests = runTests "Agda.Interaction.Options"   [ quickCheck' prop_defaultOptions+  , defaultPragmaOptionsSafe   ]

src/full/Agda/Main.hs view

@@ -37,6 +37,7 @@ import Agda.Interaction.Monad import Agda.Interaction.GhciTop ()      -- to make sure it compiles import qualified Agda.Interaction.Imports as Imp+import qualified Agda.Interaction.Highlighting.Dot as Dot import Agda.Interaction.Highlighting.HTML  import Agda.TypeChecker@@ -49,6 +50,7 @@  import Agda.Compiler.MAlonzo.Compiler as MAlonzo import Agda.Compiler.Epic.Compiler as Epic+import Agda.Compiler.JS.Compiler as JS  import Agda.Termination.TermCheck @@ -90,6 +92,7 @@       i       <- optInteractive <$> liftTCM commandLineOptions       compile <- optCompile     <$> liftTCM commandLineOptions       epic    <- optEpicCompile <$> liftTCM commandLineOptions+      js      <- optJSCompile   <$> liftTCM commandLineOptions       when i $ liftIO $ LocIO.putStr splashScreen       let failIfNoInt (Just i) = return i           -- The allowed combinations of command-line@@ -100,6 +103,7 @@           interaction | i         = runIM . interactionLoop                       | compile   = (MAlonzo.compilerMain =<<) . (failIfNoInt =<<)                       | epic      = (Epic.compilerMain    =<<) . (failIfNoInt =<<)+                      | js        = (JS.compilerMain      =<<) . (failIfNoInt =<<)                       | otherwise = (() <$)       interaction $ do         hasFile <- hasInputFile@@ -121,18 +125,11 @@             Just _  -> return Nothing             Nothing -> return $ Just i -          -- Print stats-          stats <- Map.toList <$> getStatistics-          case stats of-            []      -> return ()-            _       -> liftIO $ do-              LocIO.putStrLn "Statistics"-              LocIO.putStrLn "----------"-              mapM_ (\ (s,n) -> LocIO.putStrLn $ s ++ " : " ++ show n) $-                sortBy (\x y -> compare (snd x) (snd y)) stats-           whenM (optGenerateHTML <$> commandLineOptions) $             generateHTML $ iModuleName i++          whenM (isJust . optDependencyGraph <$> commandLineOptions) $+            Dot.generateDot $ i            return result

src/full/Agda/Syntax/Abstract.hs view

@@ -1,4 +1,4 @@-{-# LANGUAGE DeriveDataTypeable, CPP #-}+{-# LANGUAGE DeriveDataTypeable, DeriveFunctor, DeriveFoldable, DeriveTraversable, CPP #-} {-| The abstract syntax. This is what you get after desugaring and scope     analysis of the concrete syntax. The type checker works on abstract syntax,     producing internal syntax ("Agda.Syntax.Internal").@@ -21,6 +21,7 @@ import Agda.Syntax.Concrete.Pretty () import Agda.Syntax.Info import Agda.Syntax.Common+import Agda.Syntax.Fixity import Agda.Syntax.Position import Agda.Syntax.Abstract.Name import Agda.Syntax.Literal@@ -42,31 +43,63 @@ 	| WithApp ExprInfo Expr [Expr]	     -- ^ with application         | Lam  ExprInfo LamBinding Expr	     -- ^         | AbsurdLam ExprInfo Hiding+        | ExtendedLam ExprInfo DefInfo QName [Clause]         | Pi   ExprInfo Telescope Expr	     -- ^ 	| Fun  ExprInfo (Arg Expr) Expr	     -- ^ independent function space-        | Set  ExprInfo Nat		     -- ^+        | Set  ExprInfo Nat		     -- ^ Set, Set1, Set2, ...         | Prop ExprInfo			     -- ^         | Let  ExprInfo [LetBinding] Expr    -- ^         | ETel Telescope                     -- ^ only used when printing telescopes 	| Rec  ExprInfo [(C.Name, Expr)]     -- ^ record construction+	| RecUpdate ExprInfo Expr [(C.Name, Expr)]     -- ^ record update 	| ScopedExpr ScopeInfo Expr	     -- ^ scope annotation         | QuoteGoal ExprInfo Name Expr       -- ^         | Quote ExprInfo                     -- ^-        | DontCare                           -- ^ for printing DontCare from Syntax.Internal+        | QuoteTerm ExprInfo                 -- ^+        | Unquote ExprInfo                   -- ^ The splicing construct: unquote ...+        | DontCare Expr                      -- ^ for printing DontCare from Syntax.Internal   deriving (Typeable, Data, Show)  data Declaration 	= Axiom      DefInfo Relevance QName Expr          -- ^ postulate 	| Field      DefInfo QName (Arg Expr)		   -- ^ record field 	| Primitive  DefInfo QName Expr			   -- ^ primitive function-	| Definition DeclInfo [TypeSignature] [Definition] -- ^ a bunch of mutually recursive definitions+	| Mutual     DeclInfo [Declaration]                -- ^ a bunch of mutually recursive definitions 	| Section    ModuleInfo ModuleName [TypedBindings] [Declaration]-	| Apply	     ModuleInfo ModuleName [TypedBindings] ModuleName [NamedArg Expr] (Map QName QName) (Map ModuleName ModuleName)+	| Apply	     ModuleInfo ModuleName ModuleApplication (Map QName QName) (Map ModuleName ModuleName) 	| Import     ModuleInfo ModuleName 	| Pragma     Range	Pragma         | Open       ModuleInfo ModuleName           -- ^ only retained for highlighting purposes+        | FunDef     DefInfo QName [Clause]+        | DataSig    DefInfo QName Telescope Expr -- ^ lone data signature+            -- ^ the 'LamBinding's are 'DomainFree' and binds the parameters of the datatype.+        | DataDef    DefInfo QName [LamBinding] [Constructor]+            -- ^ the 'LamBinding's are 'DomainFree' and binds the parameters of the datatype.+        | RecSig     DefInfo QName Telescope Expr -- ^ lone record signature+        | RecDef     DefInfo QName (Maybe QName) [LamBinding] Expr [Declaration]+            -- ^ The 'Expr' gives the constructor type telescope, @(x1 : A1)..(xn : An) -> Prop@,+            --   and the optional name is the constructor's name. 	| ScopedDecl ScopeInfo [Declaration]  -- ^ scope annotation+        deriving (Typeable, Data, Show)++class GetDefInfo a where+  getDefInfo :: a -> Maybe DefInfo++instance GetDefInfo Declaration where+  getDefInfo (Axiom i _ _ _) = Just i+  getDefInfo (Field i _ _) = Just i+  getDefInfo (Primitive i _ _) = Just i+  getDefInfo (ScopedDecl _ (d:_)) = getDefInfo d+  getDefInfo (FunDef i _ _) = Just i+  getDefInfo (DataSig i _ _ _) = Just i+  getDefInfo (DataDef i _ _ _) = Just i+  getDefInfo (RecSig i _ _ _) = Just i+  getDefInfo (RecDef i _ _ _ _ _) = Just i+  getDefInfo _ = Nothing++data ModuleApplication = SectionApp [TypedBindings] ModuleName [NamedArg Expr]+                       | RecordModuleIFS ModuleName   deriving (Typeable, Data, Show)  data Pragma = OptionsPragma [String]@@ -75,38 +108,29 @@             | CompiledTypePragma QName String             | CompiledDataPragma QName String [String]             | CompiledEpicPragma QName String+            | CompiledJSPragma QName String+            | StaticPragma QName             | EtaPragma QName   deriving (Typeable, Data, Show) -data LetBinding = LetBind LetInfo Relevance Name Expr Expr    -- ^ LetBind info name type defn-                | LetApply ModuleInfo ModuleName [TypedBindings] ModuleName [NamedArg Expr] (Map QName QName) (Map ModuleName ModuleName)+data LetBinding = LetBind LetInfo Relevance Name Expr Expr    -- ^ LetBind info rel name type defn+                | LetApply ModuleInfo ModuleName ModuleApplication (Map QName QName) (Map ModuleName ModuleName)                 | LetOpen ModuleInfo ModuleName     -- ^ only for highlighting and abstractToConcrete   deriving (Typeable, Data, Show) --- | A definition without its type signature.-data Definition-	= FunDef     DefInfo QName [Clause]-	| DataDef    DefInfo QName [LamBinding] [Constructor]-	    -- ^ the 'LamBinding's are 'DomainFree' and binds the parameters of the datatype.-	| RecDef     DefInfo QName (Maybe Constructor) [LamBinding] Expr [Declaration]-	    -- ^ The 'Expr' gives the constructor type telescope, @(x1 : A1)..(xn : An) -> Prop@,-            --   and the optional name is the constructor's name.-        | ScopedDef ScopeInfo Definition-  deriving (Typeable, Data, Show)- -- | Only 'Axiom's. type TypeSignature  = Declaration type Constructor    = TypeSignature  -- | A lambda binding is either domain free or typed. data LamBinding-	= DomainFree Hiding Name    -- ^ . @x@ or @{x}@+	= DomainFree Hiding Relevance Name  -- ^ . @x@ or @{x}@ or @.x@ or @.{x}@ 	| DomainFull TypedBindings  -- ^ . @(xs:e)@ or @{xs:e}@   deriving (Typeable, Data, Show)  -- | Typed bindings with hiding information.-data TypedBindings = TypedBindings Range (Arg [TypedBinding])-	    -- ^ . @(xs:e;..;ys:e')@ or @{xs:e;..;ys:e'}@+data TypedBindings = TypedBindings Range (Arg TypedBinding)+	    -- ^ . @(xs : e)@ or @{xs : e}@   deriving (Typeable, Data, Show)  -- | A typed binding. Appears in dependent function spaces, typed lambdas, and@@ -148,7 +172,7 @@ 		| AbsurdP PatInfo 		| LitP Literal 		| ImplicitP PatInfo	-- ^ generated at type checking for implicit arguments-  deriving (Typeable, Data, Show)+  deriving (Typeable, Data, Show, Functor, Foldable, Traversable)  type Pattern = Pattern' Expr @@ -156,48 +180,9 @@     Instances  --------------------------------------------------------------------------} -instance Functor Pattern' where-    fmap f p = case p of-	VarP x	    -> VarP x-	ConP i c ps -> ConP i c $ (fmap . fmap . fmap . fmap) f ps-	DefP i c ps -> DefP i c $ (fmap . fmap . fmap . fmap) f ps-	LitP l	    -> LitP l-	AsP i x p   -> AsP i x $ fmap f p-	DotP i e    -> DotP i (f e)-	AbsurdP i   -> AbsurdP i-	WildP i	    -> WildP i-	ImplicitP i -> ImplicitP i---- foldr should really take its arguments in a different order!-instance Foldable Pattern' where-    foldr f z p = case p of-	VarP _	    -> z-	ConP _ _ ps -> (foldrF . foldrF . foldrF . foldrF) f ps z-	DefP _ _ ps -> (foldrF . foldrF . foldrF . foldrF) f ps z-	LitP _	    -> z-	AsP _ _ p   -> foldr f z p-	DotP _ e    -> f e z-	AbsurdP _   -> z-	WildP _	    -> z-	ImplicitP _ -> z-	where-	    foldrF f = flip (foldr f)--instance Traversable Pattern' where-    traverse f p = case p of-	VarP x	    -> pure $ VarP x-	ConP i c ps -> ConP i c <$> (traverse . traverse . traverse . traverse) f ps-	DefP i c ps -> DefP i c <$> (traverse . traverse . traverse . traverse) f ps-	LitP l	    -> pure $ LitP l-	AsP i x p   -> AsP i x <$> traverse f p-	DotP i e    -> DotP i <$> f e-	AbsurdP i   -> pure $ AbsurdP i-	WildP i	    -> pure $ WildP i-	ImplicitP i -> pure $ ImplicitP i- instance HasRange LamBinding where-    getRange (DomainFree _ x) = getRange x-    getRange (DomainFull b)   = getRange b+    getRange (DomainFree _ _ x) = getRange x+    getRange (DomainFull b)     = getRange b  instance HasRange TypedBindings where     getRange (TypedBindings r _) = r@@ -217,35 +202,38 @@     getRange (WithApp i _ _)	= getRange i     getRange (Lam i _ _)	= getRange i     getRange (AbsurdLam i _)    = getRange i+    getRange (ExtendedLam i _ _ _)  = getRange i     getRange (Pi i _ _)		= getRange i     getRange (Fun i _ _)	= getRange i     getRange (Set i _)		= getRange i     getRange (Prop i)		= getRange i     getRange (Let i _ _)	= getRange i     getRange (Rec i _)		= getRange i+    getRange (RecUpdate i _ _)  = getRange i     getRange (ETel tel)         = getRange tel     getRange (ScopedExpr _ e)	= getRange e     getRange (QuoteGoal _ _ e)	= getRange e     getRange (Quote i)  	= getRange i-    getRange (DontCare)         = noRange+    getRange (QuoteTerm i)  	= getRange i+    getRange (Unquote i)  	= getRange i+    getRange (DontCare{})       = noRange  instance HasRange Declaration where     getRange (Axiom      i _ _ _       ) = getRange i     getRange (Field      i _ _         ) = getRange i-    getRange (Definition i _ _	       ) = getRange i+    getRange (Mutual     i _           ) = getRange i     getRange (Section    i _ _ _       ) = getRange i-    getRange (Apply	 i _ _ _ _ _ _ ) = getRange i+    getRange (Apply	 i _ _ _ _     ) = getRange i     getRange (Import     i _	       ) = getRange i     getRange (Primitive  i _ _	       ) = getRange i     getRange (Pragma	 i _	       ) = getRange i     getRange (Open       i _           ) = getRange i     getRange (ScopedDecl _ d	       ) = getRange d--instance HasRange Definition where-    getRange (FunDef  i _ _    )   = getRange i-    getRange (DataDef i _ _ _  )   = getRange i-    getRange (RecDef  i _ _ _ _ _) = getRange i-    getRange (ScopedDef _ d)       = getRange d+    getRange (FunDef  i _ _         ) = getRange i+    getRange (DataSig i _ _ _       ) = getRange i+    getRange (DataDef i _ _ _       ) = getRange i+    getRange (RecSig  i _ _ _       ) = getRange i+    getRange (RecDef  i _ _ _ _ _   ) = getRange i  instance HasRange (Pattern' e) where     getRange (VarP x)	   = getRange x@@ -272,12 +260,12 @@  instance HasRange LetBinding where     getRange (LetBind  i _ _ _ _     ) = getRange i-    getRange (LetApply i _ _ _ _ _ _ ) = getRange i+    getRange (LetApply i _ _ _ _     ) = getRange i     getRange (LetOpen  i _           ) = getRange i  instance KillRange LamBinding where-  killRange (DomainFree h x) = killRange1 (DomainFree h) x-  killRange (DomainFull b)   = killRange1 DomainFull b+  killRange (DomainFree h r x) = killRange1 (DomainFree h r) x+  killRange (DomainFull b)     = killRange1 DomainFull b  instance KillRange TypedBindings where   killRange (TypedBindings r b) = TypedBindings (killRange r) (killRange b)@@ -297,17 +285,21 @@   killRange (WithApp i e es) = killRange3 WithApp i e es   killRange (Lam i b e)      = killRange3 Lam i b e   killRange (AbsurdLam i h)  = killRange1 AbsurdLam i h+  killRange (ExtendedLam i name di pes) = killRange4 ExtendedLam i name di pes --(\_ -> ExtendedLam i def {-name di si-}) i pes   killRange (Pi i a b)       = killRange3 Pi i a b   killRange (Fun i a b)      = killRange3 Fun i a b   killRange (Set i n)        = Set (killRange i) n   killRange (Prop i)         = killRange1 Prop i   killRange (Let i ds e)     = killRange3 Let i ds e   killRange (Rec i fs)       = Rec (killRange i) (map (id -*- killRange) fs)+  killRange (RecUpdate i e fs) = RecUpdate (killRange i) (killRange e) (map (id -*- killRange) fs)   killRange (ETel tel)       = killRange1 ETel tel   killRange (ScopedExpr s e) = killRange1 (ScopedExpr s) e   killRange (QuoteGoal i x e)= killRange3 QuoteGoal i x e   killRange (Quote i)        = killRange1 Quote i-  killRange (DontCare)       = DontCare+  killRange (QuoteTerm i)    = killRange1 QuoteTerm i+  killRange (Unquote i)      = killRange1 Unquote i+  killRange (DontCare e)     = DontCare e  instance KillRange Relevance where   killRange rel = rel -- no range to kill@@ -315,22 +307,28 @@ instance KillRange Declaration where   killRange (Axiom      i rel a b     ) = killRange4 Axiom      i rel a b   killRange (Field      i a b         ) = killRange3 Field      i a b-  killRange (Definition i a b         ) = killRange3 Definition i a b+  killRange (Mutual     i a           ) = killRange2 Mutual     i a   killRange (Section    i a b c       ) = killRange4 Section    i a b c-  killRange (Apply      i a b c d e f ) = killRange5 Apply      i a b c d e f+  killRange (Apply      i a b c d     ) = killRange3 Apply      i a b c d    -- the last two arguments of Apply are name maps, so nothing to kill   killRange (Import     i a           ) = killRange2 Import     i a   killRange (Primitive  i a b         ) = killRange3 Primitive  i a b   killRange (Pragma     i a           ) = Pragma (killRange i) a   killRange (Open       i x           ) = killRange2 Open       i x   killRange (ScopedDecl a d           ) = killRange1 (ScopedDecl a) d+  killRange (FunDef  i a b       ) = killRange3 FunDef  i a b+  killRange (DataSig i a b c     ) = killRange3 DataSig i a b c+  killRange (DataDef i a b c     ) = killRange4 DataDef i a b c+  killRange (RecSig  i a b c     ) = killRange4 RecSig  i a b c+  killRange (RecDef  i a b c d e ) = killRange6 RecDef  i a b c d e -instance KillRange Definition where-  killRange (FunDef  i a b    )   = killRange3 FunDef  i a b-  killRange (DataDef i a b c)     = killRange4 DataDef i a b c-  killRange (RecDef  i a b c d e) = killRange6 RecDef  i a b c d e-  killRange (ScopedDef s a)       = killRange1 (ScopedDef s) a+instance KillRange ModuleApplication where+  killRange (SectionApp a b c  ) = killRange3 SectionApp a b c+  killRange (RecordModuleIFS a ) = killRange1 RecordModuleIFS a +instance KillRange x => KillRange (ThingWithFixity x) where+  killRange (ThingWithFixity c f) = ThingWithFixity (killRange c) f+ instance KillRange e => KillRange (Pattern' e) where   killRange (VarP x)      = killRange1 VarP x   killRange (ConP i a b)  = killRange3 ConP i a b@@ -356,7 +354,7 @@  instance KillRange LetBinding where   killRange (LetBind  i rel a b c   ) = killRange5 LetBind  i rel a b c-  killRange (LetApply i a b c d e f ) = killRange5 LetApply i a b c d e f+  killRange (LetApply i a b c d     ) = killRange3 LetApply i a b c d   killRange (LetOpen  i x           ) = killRange2 LetOpen  i x  ------------------------------------------------------------------------@@ -365,32 +363,80 @@  -- | Extracts all the names which are declared in a 'Declaration'. -- This does not include open public or let expressions, but it does--- include local modules and where clauses.+-- include local modules, where clauses and the names of extended+-- lambdas.  allNames :: Declaration -> Seq QName-allNames (Axiom     _ _ q _)   = Seq.singleton q-allNames (Field     _   q _)   = Seq.singleton q-allNames (Primitive _   q _)   = Seq.singleton q-allNames (Definition _ _ defs) = Fold.foldMap allNamesD defs+allNames (Axiom     _ _ q _)      = Seq.singleton q+allNames (Field     _   q _)      = Seq.singleton q+allNames (Primitive _   q _)      = Seq.singleton q+allNames (Mutual     _ defs)      = Fold.foldMap allNames defs+allNames (DataSig _ q _ _)        = Seq.singleton q+allNames (DataDef _ q _ decls)    = q <| Fold.foldMap allNames decls+allNames (RecSig _ q _ _)         = Seq.singleton q+allNames (RecDef _ q c _ _ decls) =+  q <| foldMap Seq.singleton c >< Fold.foldMap allNames decls+allNames (FunDef _ q cls)         = q <| Fold.foldMap allNamesC cls   where-  allNamesD :: Definition -> Seq QName-  allNamesD (FunDef _ q cls)         = q <| Fold.foldMap allNamesC cls-  allNamesD (DataDef _ q _ decls)    = q <| Fold.foldMap allNames decls-  allNamesD (ScopedDef _ def)        = allNamesD def-  allNamesD (RecDef _ q c _ _ decls) =-    q <| Fold.foldMap allNames c >< Fold.foldMap allNames decls-   allNamesC :: Clause -> Seq QName   allNamesC (Clause _ rhs decls) = allNamesR rhs ><                                    Fold.foldMap allNames decls    allNamesR :: RHS -> Seq QName-  allNamesR RHS {}                = Seq.empty+  allNamesR (RHS e)               = allNamesE e   allNamesR AbsurdRHS {}          = Seq.empty   allNamesR (WithRHS q _ cls)     = q <| Fold.foldMap allNamesC cls   allNamesR (RewriteRHS qs _ rhs cls) =     Seq.fromList qs >< allNamesR rhs                     >< Fold.foldMap allNames cls++  allNamesE :: Expr -> Seq QName+  allNamesE Var {}                  = Seq.empty+  allNamesE Def {}                  = Seq.empty+  allNamesE Con {}                  = Seq.empty+  allNamesE Lit {}                  = Seq.empty+  allNamesE QuestionMark {}         = Seq.empty+  allNamesE Underscore {}           = Seq.empty+  allNamesE (App _ e1 e2)           = Fold.foldMap allNamesE [e1, namedThing (unArg e2)]+  allNamesE (WithApp _ e es)        = Fold.foldMap allNamesE (e : es)+  allNamesE (Lam _ b e)             = allNamesLam b >< allNamesE e+  allNamesE AbsurdLam {}            = Seq.empty+  allNamesE (ExtendedLam _ _ q cls) = q <| Fold.foldMap allNamesC cls+  allNamesE (Pi _ tel e)            = Fold.foldMap allNamesBinds tel ><+                                                allNamesE e+  allNamesE (Fun _ (Arg _ _ e1) e2) = Fold.foldMap allNamesE [e1, e2]+  allNamesE Set {}                  = Seq.empty+  allNamesE Prop {}                 = Seq.empty+  allNamesE (Let _ lbs e)           = Fold.foldMap allNamesLet lbs ><+                                                allNamesE e+  allNamesE ETel {}                 = __IMPOSSIBLE__+  allNamesE (Rec _ fields)          = Fold.foldMap allNamesE (map snd fields)+  allNamesE (RecUpdate _ e fs)      = allNamesE e >< Fold.foldMap allNamesE (map snd fs)+  allNamesE (ScopedExpr _ e)        = allNamesE e+  allNamesE (QuoteGoal _ _ e)       = allNamesE e+  allNamesE Quote {}                = Seq.empty+  allNamesE QuoteTerm {}            = Seq.empty+  allNamesE Unquote {}              = Seq.empty+  allNamesE DontCare {}             = Seq.empty++  allNamesLam :: LamBinding -> Seq QName+  allNamesLam DomainFree {}      = Seq.empty+  allNamesLam (DomainFull binds) = allNamesBinds binds++  allNamesBinds :: TypedBindings -> Seq QName+  allNamesBinds (TypedBindings _ (Arg _ _ (TBind _ _ e))) = allNamesE e+  allNamesBinds (TypedBindings _ (Arg _ _ (TNoBind e)))   = allNamesE e++  allNamesLet :: LetBinding -> Seq QName+  allNamesLet (LetBind _ _ _ e1 e2)  = Fold.foldMap allNamesE [e1, e2]+  allNamesLet (LetApply _ _ app _ _) = allNamesApp app+  allNamesLet LetOpen {}             = Seq.empty++  allNamesApp :: ModuleApplication -> Seq QName+  allNamesApp (SectionApp bindss _ es) = Fold.foldMap allNamesBinds bindss ><+                                         Fold.foldMap allNamesE (map (namedThing . unArg) es)+  allNamesApp RecordModuleIFS {}       = Seq.empty+ allNames (Section _ _ _ decls) = Fold.foldMap allNames decls allNames Apply {}              = Seq.empty allNames Import {}             = Seq.empty@@ -405,3 +451,26 @@ axiomName :: Declaration -> QName axiomName (Axiom _ _ q _) = q axiomName _             = __IMPOSSIBLE__++-- | Are we in an abstract block?+--+--   In that case some definition is abstract.+class AnyAbstract a where+  anyAbstract :: a -> Bool++instance AnyAbstract a => AnyAbstract [a] where+  anyAbstract = Fold.any anyAbstract++instance AnyAbstract Declaration where+  anyAbstract (Axiom i _ _ _)     = defAbstract i == AbstractDef+  anyAbstract (Field i _ _)       = defAbstract i == AbstractDef+  anyAbstract (Mutual     _ ds)   = anyAbstract ds+  anyAbstract (ScopedDecl _ ds)   = anyAbstract ds+  anyAbstract (Section _ _ _ ds)  = anyAbstract ds+  anyAbstract (FunDef i _ _)       = defAbstract i == AbstractDef+  anyAbstract (DataDef i _ _ _)    = defAbstract i == AbstractDef+  anyAbstract (RecDef i _ _ _ _ _) = defAbstract i == AbstractDef+  anyAbstract (DataSig i _ _ _)    = defAbstract i == AbstractDef+  anyAbstract (RecSig i _ _ _)     = defAbstract i == AbstractDef+  anyAbstract _                    = __IMPOSSIBLE__+

src/full/Agda/Syntax/Abstract/Name.hs view

@@ -123,6 +123,9 @@ qnameToMName :: QName -> ModuleName qnameToMName = mnameFromList . qnameToList +mnameToQName :: ModuleName -> QName+mnameToQName = qnameFromList . mnameToList+ showQNameId :: QName -> String showQNameId q = show ns ++ "@" ++ show m   where

src/full/Agda/Syntax/Abstract/Pretty.hs view

@@ -10,18 +10,18 @@ import Agda.TypeChecking.Monad import Agda.Utils.Pretty -showA :: (Show c, ToConcrete a c, MonadTCM tcm) => a -> tcm String+showA :: (Show c, ToConcrete a c) => a -> TCM String showA x = show <$> abstractToConcrete_ x -prettyA :: (Pretty c, ToConcrete a c, MonadTCM tcm) => a -> tcm Doc+prettyA :: (Pretty c, ToConcrete a c) => a -> TCM Doc prettyA x = pretty <$> abstractToConcrete_ x  -- | Variant of 'showA' which does not insert outermost parentheses. -showATop :: (Show c, ToConcrete a c, MonadTCM tcm) => a -> tcm String+showATop :: (Show c, ToConcrete a c) => a -> TCM String showATop x = show <$> abstractToConcreteCtx TopCtx x  -- | Variant of 'prettyA' which does not insert outermost parentheses. -prettyATop :: (Pretty c, ToConcrete a c, MonadTCM tcm) => a -> tcm Doc+prettyATop :: (Pretty c, ToConcrete a c) => a -> TCM Doc prettyATop x = pretty <$> abstractToConcreteCtx TopCtx x

src/full/Agda/Syntax/Abstract/Views.hs view

@@ -6,41 +6,23 @@ import Agda.Syntax.Abstract import Agda.Syntax.Info -data AppView = Application Head [NamedArg Expr]-	     | NonApplication Expr-		-- ^ TODO: if we allow beta-redexes (which we currently do) there could be one here.---- | @Head@ of an applicative expression.-data Head = HeadVar Name     -- ^ A variable.-	  | HeadDef QName    -- ^ A defined symbol (except constructor).-	  | HeadCon [QName]  -- ^ A constructor which could belong to any of the data types in the list.+data AppView = Application Expr [NamedArg Expr]+	     -- NonApplication Expr+	     --    -- ^ TODO: if we allow beta-redexes (which we currently do) there could be one here.+             -- 2011-08-24, Dominique: removed.. +-- note: everything is an application, possibly of itself to 0 arguments appView :: Expr -> AppView appView e =     case e of-	Var x	       -> Application (HeadVar x) []-	Def x	       -> Application (HeadDef x) []-	Con (AmbQ x)   -> Application (HeadCon x) []-	App i e1 arg   -> apply i (appView e1) arg-	ScopedExpr _ e -> appView e-	_	       -> NonApplication e+      App i e1 arg        -> apply i (appView e1) arg+      ScopedExpr _ e      -> appView e+      _                   -> Application e []     where 	apply i v arg = 	    case v of 		Application hd es -> Application hd $ es ++ [arg]-		NonApplication e  -> NonApplication (App i e arg) -headToExpr :: Head -> Expr-headToExpr (HeadVar x)  = Var x-headToExpr (HeadDef f)  = Def f-headToExpr (HeadCon cs) = Con (AmbQ cs)- unAppView :: AppView -> Expr-unAppView (NonApplication e) = e unAppView (Application h es) =-  foldl (App (ExprRange noRange)) (headToExpr h) es--instance HasRange Head where-    getRange (HeadVar x) = getRange x-    getRange (HeadDef x) = getRange x-    getRange (HeadCon x) = getRange x+  foldl (App (ExprRange noRange)) h es

src/full/Agda/Syntax/Common.hs view

@@ -1,4 +1,5 @@-{-# LANGUAGE CPP, FlexibleInstances, DeriveDataTypeable #-}+{-# LANGUAGE CPP, FlexibleInstances, DeriveDataTypeable,+             DeriveFunctor, DeriveFoldable, DeriveTraversable #-}  {-| Some common syntactic entities are defined in this module. -}@@ -20,26 +21,39 @@ data Induction = Inductive | CoInductive   deriving (Typeable, Data, Show, Eq, Ord) -data Hiding  = Hidden | NotHidden+data Hiding  = Hidden | Instance | NotHidden     deriving (Typeable, Data, Show, Eq, Ord)  -- | A function argument can be relevant or irrelevant.+--   See 'Agda.TypeChecking.Irrelevance'. data Relevance   = Relevant    -- ^ the argument is (possibly) relevant at compile-time+  | NonStrict   -- ^ the argument may never flow into evaluation position.+                --   Therefore, it is irrelevant at run-time.+                --   It is treated relevantly during equality checking.   | Irrelevant  -- ^ the argument is irrelevant at compile- and runtime   | Forced      -- ^ the argument can be skipped during equality checking-    deriving (Typeable, Data, Show, Eq, Ord)+    deriving (Typeable, Data, Show, Eq) --- | For comparing @Relevance@ ignoring @Forced@.-ignoreForced :: Relevance -> Relevance-ignoreForced Forced     = Relevant-ignoreForced Relevant   = Relevant-ignoreForced Irrelevant = Irrelevant+instance Ord Relevance where+  (<=) = moreRelevant --- | @Relevance@ from @Bool@.-irrelevant :: Bool -> Relevance-irrelevant True  = Irrelevant-irrelevant False = Relevant+-- | Information ordering.+-- @Relevant `moreRelevant` Forced `moreRelevant` NonStrict `moreRelevant` Irrelevant@+moreRelevant :: Relevance -> Relevance -> Bool+moreRelevant r r' =+  case (r, r') of+    -- top+    (_, Irrelevant) -> True+    (Irrelevant, _) -> False+    -- bottom+    (Relevant, _)   -> True+    (_, Relevant)   -> False+    -- second bottom+    (Forced, _)     -> True+    (_, Forced)     -> False+    -- remaining case+    (NonStrict,NonStrict) -> True  instance KillRange Induction where killRange = id instance KillRange Hiding    where killRange = id@@ -49,11 +63,14 @@   { argHiding    :: Hiding   , argRelevance :: Relevance   , unArg :: e-  } deriving (Typeable, Data, Ord)+  } deriving (Typeable, Data, Ord, Functor, Foldable, Traversable)  instance Eq a => Eq (Arg a) where   Arg h1 _ x1 == Arg h2 _ x2 = (h1, x1) == (h2, x2) +makeInstance :: Arg a -> Arg a+makeInstance a = a { argHiding = Instance }+ hide :: Arg a -> Arg a hide a = a { argHiding = Hidden } @@ -61,15 +78,7 @@ defaultArg = Arg NotHidden Relevant  isHiddenArg :: Arg a -> Bool-isHiddenArg arg = argHiding arg == Hidden--makeIrrelevant :: Arg a -> Arg a-makeIrrelevant a = a { argRelevance = Irrelevant }--makeRelevant :: Arg a -> Arg a-makeRelevant a = if argRelevance a == Irrelevant-                  then a { argRelevance = Relevant }-                  else a+isHiddenArg arg = argHiding arg /= NotHidden  -- | @xs `withArgsFrom` args@ translates @xs@ into a list of 'Arg's, -- using the elements in @args@ to fill in the non-'unArg' fields.@@ -80,15 +89,6 @@ xs `withArgsFrom` args =   zipWith (\x arg -> fmap (const x) arg) xs args -instance Functor Arg where-    fmap f a = a { unArg = f (unArg a) }--instance Foldable Arg where-    foldr f z a = f (unArg a) z--instance Traversable Arg where-    traverse f (Arg h r x) = Arg h r <$> f x- instance HasRange a => HasRange (Arg a) where     getRange = getRange . unArg @@ -103,7 +103,9 @@       where         showH Hidden     s = "{" ++ s ++ "}"         showH NotHidden  s = "(" ++ s ++ ")"+        showH Instance   s = "{{" ++ s ++ "}}"         showR Irrelevant s = "." ++ s+        showR NonStrict  s = "?" ++ s         showR Forced     s = "!" ++ s         showR Relevant   s = "r" ++ s -- Andreas: I want to see it explicitly @@ -111,7 +113,7 @@     Named { nameOf     :: Maybe name 	  , namedThing :: a 	  }-    deriving (Eq, Ord, Typeable, Data)+    deriving (Eq, Ord, Typeable, Data, Functor, Foldable, Traversable)  unnamed :: a -> Named name a unnamed = Named Nothing@@ -119,15 +121,6 @@ named :: name -> a -> Named name a named = Named . Just -instance Functor (Named name) where-    fmap f (Named n x) = Named n $ f x--instance Foldable (Named name) where-    foldr f z (Named _ x) = f x z--instance Traversable (Named name) where-    traverse f (Named n x) = Named n <$> f x- instance HasRange a => HasRange (Named name a) where     getRange = getRange . namedThing @@ -151,6 +144,8 @@  -- | Access modifier. data Access = PrivateAccess | PublicAccess+            | OnlyQualified  -- ^ Visible from outside, but not exported when opening the module+                             --   Used for qualified constructors.     deriving (Typeable, Data, Show, Eq, Ord)  -- | Abstract or concrete

src/full/Agda/Syntax/Concrete.hs view

@@ -1,4 +1,4 @@-{-# LANGUAGE CPP, DeriveDataTypeable #-}+{-# LANGUAGE CPP, DeriveDataTypeable, DeriveFunctor, DeriveTraversable, DeriveFoldable #-}  {-| The concrete syntax is a raw representation of the program text     without any desugaring at all.  This is what the parser produces.@@ -8,6 +8,7 @@ module Agda.Syntax.Concrete     ( -- * Expressions       Expr(..)+    , OpApp(..), fromOrdinary     , module Agda.Syntax.Concrete.Name     , appView, AppView(..)       -- * Bindings@@ -18,6 +19,7 @@     , Telescope -- (..)       -- * Declarations     , Declaration(..)+    , ModuleApplication(..)     , TypeSignature     , Constructor     , Field@@ -29,12 +31,16 @@     , RHS(..), WhereClause(..)     , Pragma(..)     , Module+    , ThingWithFixity(..)     , topLevelModuleName+    -- * Pattern tools+    , patternHead, patternNames     )     where  import Data.Generics (Typeable, Data)-+import Data.Foldable hiding (concatMap)+import Data.Traversable import Agda.Syntax.Position import Agda.Syntax.Common import Agda.Syntax.Fixity@@ -46,6 +52,15 @@ import Agda.Utils.Impossible #include "../undefined.h" +data OpApp e+        = SyntaxBindingLambda !Range [LamBinding] e -- ^ an abstraction inside a special syntax declaration (see Issue 358 why we introduce this).+        | Ordinary e+    deriving (Typeable, Data, Functor)++fromOrdinary :: e -> OpApp e -> e+fromOrdinary d (Ordinary e) = e+fromOrdinary d _            = d+ -- | Concrete expressions. Should represent exactly what the user wrote. data Expr 	= Ident QName			       -- ^ ex: @x@@@ -54,17 +69,20 @@ 	| Underscore !Range (Maybe Nat)	       -- ^ ex: @_@ 	| RawApp !Range [Expr]		       -- ^ before parsing operators 	| App !Range Expr (NamedArg Expr)      -- ^ ex: @e e@, @e {e}@, or @e {x = e}@-	| OpApp !Range Name [Expr]	       -- ^ ex: @e + e@+	| OpApp !Range Name [OpApp Expr]       -- ^ ex: @e + e@         | WithApp !Range Expr [Expr]           -- ^ ex: @e | e1 | .. | en@ 	| HiddenArg !Range (Named String Expr) -- ^ ex: @{e}@ or @{x=e}@+	| InstanceArg !Range (Named String Expr) -- ^ ex: @{{e}}@ or @{{x=e}}@ 	| Lam !Range [LamBinding] Expr	       -- ^ ex: @\\x {y} -> e@ or @\\(x:A){y:B} -> e@         | AbsurdLam !Range Hiding              -- ^ ex: @\\ ()@+        | ExtendedLam !Range [(LHS,RHS,WhereClause)]       -- ^ ex: @\\ { p11 .. p1a -> e1 ; .. ; pn1 .. pnz -> en }@ 	| Fun !Range Expr Expr                 -- ^ ex: @e -> e@ or @.e -> e@ (NYI: @{e} -> e@) 	| Pi Telescope Expr		       -- ^ ex: @(xs:e) -> e@ or @{xs:e} -> e@ 	| Set !Range			       -- ^ ex: @Set@ 	| Prop !Range			       -- ^ ex: @Prop@ 	| SetN !Range Nat		       -- ^ ex: @Set0, Set1, ..@ 	| Rec !Range [(Name, Expr)]	       -- ^ ex: @record {x = a; y = b}@+	| RecUpdate !Range Expr [(Name, Expr)] -- ^ ex: @record e {x = a; y = b}@ 	| Let !Range [Declaration] Expr	       -- ^ ex: @let Ds in e@ 	| Paren !Range Expr		       -- ^ ex: @(e)@ 	| Absurd !Range			       -- ^ ex: @()@ or @{}@, only in patterns@@ -73,6 +91,9 @@         | ETel Telescope                       -- ^ only used for printing telescopes         | QuoteGoal !Range Name Expr           -- ^ ex: @quoteGoal x in e@         | Quote !Range                         -- ^ ex: @quote@, should be applied to a name+        | QuoteTerm !Range                     -- ^ ex: @quoteTerm@, should be applied to a term+        | Unquote !Range                       -- ^ ex: @unquote@, should be applied to a term of type @Term@+        | DontCare Expr                        -- ^ to print irrelevant things     deriving (Typeable, Data)  @@ -83,6 +104,7 @@ 	| RawAppP !Range [Pattern] 	| OpAppP !Range Name [Pattern] 	| HiddenP !Range (Named String Pattern)+	| InstanceP !Range (Named String Pattern) 	| ParenP !Range Pattern 	| WildP !Range 	| AbsurdP !Range@@ -94,15 +116,15 @@  -- | A lambda binding is either domain free or typed. data LamBinding-	= DomainFree Hiding BoundName -- ^ . @x@ or @{x}@-	| DomainFull TypedBindings    -- ^ . @(xs:e,..,ys:e')@ or @{xs:e,..,ys:e'}@+	= DomainFree Hiding Relevance BoundName -- ^ . @x@ or @{x}@ or @.x@ or @.{x}@ or @{.x}@+	| DomainFull TypedBindings              -- ^ . @(xs : e)@ or @{xs : e}@     deriving (Typeable, Data)   -- | A sequence of typed bindings with hiding information. Appears in dependent --   function spaces, typed lambdas, and telescopes.-data TypedBindings = TypedBindings !Range (Arg [TypedBinding])-	-- ^ . @(xs:e;..;ys:e')@ or @{xs:e;..;ys:e'}@+data TypedBindings = TypedBindings !Range (Arg TypedBinding)+	-- ^ . @(xs : e)@ or @{xs : e}@     deriving (Typeable, Data)  @@ -132,7 +154,11 @@     We use fixity information to see which name is actually defined. -}-data LHS = LHS Pattern [Pattern] [RewriteEqn] [WithExpr]+data LHS = LHS { lhsOriginalPattern :: Pattern+               , lhsWithPattern     :: [Pattern]+               , lhsRewriteEqn      :: [RewriteEqn]+               , lhsWithExpr        :: [WithExpr]+               }          -- ^ original pattern, with-patterns, rewrite equations and with-expressions          | Ellipsis Range [Pattern] [RewriteEqn] [WithExpr]          -- ^ new with-patterns, rewrite equations and with-expressions@@ -193,7 +219,7 @@                        -- ^ The range of the \"as\" keyword. Retained                        --   for highlighting purposes.                      }-    deriving (Typeable, Data)+    deriving (Typeable, Data, Show)  {--------------------------------------------------------------------------     Declarations@@ -209,12 +235,15 @@ {-| The representation type of a declaration. The comments indicate     which type in the intended family the constructor targets. -}+ data Declaration 	= TypeSig Relevance Name Expr -- ^ Axioms and functions can be irrelevant.         | Field Name (Arg Expr) -- ^ Record field, can be hidden and/or irrelevant. 	| FunClause LHS RHS WhereClause-	| Data        !Range Induction Name [TypedBindings] Expr [Constructor]-	| Record      !Range Name (Maybe Name) [TypedBindings] Expr [Declaration]+	| DataSig     !Range Induction Name [LamBinding] Expr -- ^ lone data signature in mutual block+	| Data        !Range Induction Name [LamBinding] (Maybe Expr) [Constructor]+	| RecordSig   !Range Name [LamBinding] Expr -- ^ lone record signature in mutual block+	| Record      !Range Name (Maybe Name) [LamBinding] (Maybe Expr) [Declaration]           -- ^ The optional name is a name for the record constructor. 	| Infix Fixity [Name]         | Syntax      Name Notation -- ^ notation declaration for a name@@ -225,11 +254,15 @@ 	| Primitive   !Range [TypeSignature] 	| Open        !Range QName ImportDirective 	| Import      !Range QName (Maybe AsName) OpenShortHand ImportDirective-	| ModuleMacro !Range  Name [TypedBindings] Expr OpenShortHand ImportDirective+	| ModuleMacro !Range  Name ModuleApplication OpenShortHand ImportDirective 	| Module      !Range QName [TypedBindings] [Declaration] 	| Pragma      Pragma     deriving (Typeable, Data) +data ModuleApplication = SectionApp Range [TypedBindings] Expr+                       | RecordModuleIFS Range QName+    deriving (Typeable, Data)+ data OpenShortHand = DoOpen | DontOpen     deriving (Typeable, Data, Show) @@ -241,6 +274,8 @@             | CompiledTypePragma !Range QName String             | CompiledPragma    !Range QName String             | CompiledEpicPragma !Range QName String+            | CompiledJSPragma  !Range QName String+            | StaticPragma      !Range QName             | ImportPragma      !Range String               -- ^ Invariant: The string must be a valid Haskell               -- module name.@@ -282,9 +317,55 @@ appView e = AppView e []  {--------------------------------------------------------------------------+    Patterns+ --------------------------------------------------------------------------}++-- | Get the leftmost symbol in a pattern.+patternHead :: Pattern -> Maybe Name+patternHead p =+  case p of+    IdentP x             -> return $ unqualify x+    AppP p p'            -> patternHead p+    RawAppP _ []         -> __IMPOSSIBLE__+    RawAppP _ (p:_)      -> patternHead p+    OpAppP _ name ps     -> return $ name+    HiddenP _ (namedPat) -> patternHead (namedThing namedPat)+    ParenP _ p           -> patternHead p+    WildP _              -> Nothing+    AbsurdP _            -> Nothing+    AsP _ x p            -> patternHead p+    DotP{}               -> Nothing+    LitP (LitQName _ x)  -> Nothing -- return $ unqualify x -- does not compile+    LitP _               -> Nothing+    InstanceP _ (namedPat) -> patternHead (namedThing namedPat)+++-- | Get all the identifiers in a pattern in left-to-right order.+patternNames :: Pattern -> [Name]+patternNames p =+  case p of+    IdentP x             -> [unqualify x]+    AppP p p'            -> concatMap patternNames [p, namedThing $ unArg p']+    RawAppP _ ps         -> concatMap patternNames  ps+    OpAppP _ name ps     -> name : concatMap patternNames ps+    HiddenP _ (namedPat) -> patternNames (namedThing namedPat)+    ParenP _ p           -> patternNames p+    WildP _              -> []+    AbsurdP _            -> []+    AsP _ x p            -> patternNames p+    DotP{}               -> []+    LitP _               -> []+    InstanceP _ (namedPat) -> patternNames (namedThing namedPat)++{--------------------------------------------------------------------------     Instances  --------------------------------------------------------------------------} +instance HasRange e => HasRange (OpApp e) where+    getRange e = case e of+        Ordinary e -> getRange e+        SyntaxBindingLambda r _ _ -> r+ instance HasRange Expr where     getRange e = 	case e of@@ -298,6 +379,7 @@             WithApp r _ _       -> r 	    Lam r _ _		-> r             AbsurdLam r _       -> r+            ExtendedLam r _       -> r 	    Fun r _ _		-> r 	    Pi b e		-> fuseRange b e 	    Set r		-> r@@ -309,10 +391,15 @@ 	    Dot r _		-> r 	    Absurd r		-> r 	    HiddenArg r _	-> r+	    InstanceArg r _	-> r 	    Rec r _		-> r+	    RecUpdate r _ _	-> r             ETel tel            -> getRange tel             QuoteGoal r _ _     -> r             Quote r             -> r+            QuoteTerm r         -> r+            Unquote r           -> r+            DontCare{}          -> noRange  -- instance HasRange Telescope where --     getRange (TeleBind bs) = getRange bs@@ -326,7 +413,7 @@     getRange (TNoBind e)   = getRange e  instance HasRange LamBinding where-    getRange (DomainFree _ x)	= getRange x+    getRange (DomainFree _ _ x)	= getRange x     getRange (DomainFull b)	= getRange b  instance HasRange BoundName where@@ -337,16 +424,22 @@   getRange (AnyWhere ds)    = getRange ds   getRange (SomeWhere _ ds) = getRange ds +instance HasRange ModuleApplication where+  getRange (SectionApp r _ _) = r+  getRange (RecordModuleIFS r _) = r+ instance HasRange Declaration where     getRange (TypeSig _ x t)	       = fuseRange x t     getRange (Field x t)               = fuseRange x t     getRange (FunClause lhs rhs wh)    = fuseRange lhs rhs `fuseRange` wh+    getRange (DataSig r _ _ _ _)       = r     getRange (Data r _ _ _ _ _)	       = r+    getRange (RecordSig r _ _ _)       = r     getRange (Record r _ _ _ _ _)      = r     getRange (Mutual r _)	       = r     getRange (Abstract r _)	       = r     getRange (Open r _ _)	       = r-    getRange (ModuleMacro r _ _ _ _ _) = r+    getRange (ModuleMacro r _ _ _ _)   = r     getRange (Import r _ _ _ _)	       = r     getRange (Private r _)	       = r     getRange (Postulate r _)	       = r@@ -371,6 +464,8 @@     getRange (CompiledTypePragma r _ _)   = r     getRange (CompiledPragma r _ _)       = r     getRange (CompiledEpicPragma r _ _)   = r+    getRange (CompiledJSPragma r _ _)     = r+    getRange (StaticPragma r _)           = r     getRange (ImportPragma r _)           = r     getRange (ImpossiblePragma r)         = r     getRange (EtaPragma r _)              = r@@ -403,4 +498,5 @@     getRange (AbsurdP r)	= r     getRange (LitP l)		= getRange l     getRange (HiddenP r _)	= r+    getRange (InstanceP r _)	= r     getRange (DotP r _)		= r

src/full/Agda/Syntax/Concrete/Definitions.hs view

@@ -2,7 +2,6 @@  module Agda.Syntax.Concrete.Definitions     ( NiceDeclaration(..)-    , NiceDefinition(..)     , NiceConstructor, NiceTypeSignature     , Clause(..)     , DeclarationException(..)@@ -11,15 +10,19 @@     , notSoNiceDeclarations     ) where +import Control.Arrow ((***), (&&&)) import Control.Applicative- import Data.Generics (Typeable, Data)+import Data.Foldable hiding (concatMap, mapM_, notElem, elem, all) import qualified Data.Map as Map+import Data.Map (Map) import Control.Monad.Error+import Control.Monad.State import Data.List import Data.Maybe-import qualified Data.Traversable as Trav+import Data.Traversable (traverse) +import Debug.Trace (trace) import Agda.Syntax.Concrete import Agda.Syntax.Common import Agda.Syntax.Position@@ -27,10 +30,18 @@ import Agda.Syntax.Notation import Agda.Syntax.Concrete.Pretty import Agda.Utils.Pretty+import Agda.Utils.List (mhead, isSublistOf)+import Agda.Utils.Monad  #include "../../undefined.h" import Agda.Utils.Impossible +import Control.Applicative+import Control.Monad.Error+import Data.Char++import Debug.Trace+ {--------------------------------------------------------------------------     Types  --------------------------------------------------------------------------}@@ -41,78 +52,81 @@     modifiers have been distributed to the individual declarations. -} data NiceDeclaration-	= Axiom Range Fixity' Access IsAbstract Relevance Name Expr+        = Axiom Range Fixity' Access Relevance Name Expr             -- ^ Axioms and functions can be declared irrelevant.         | NiceField Range Fixity' Access IsAbstract Name (Arg Expr)-	| PrimitiveFunction Range Fixity' Access IsAbstract Name Expr-	| NiceDef Range [Declaration] [NiceTypeSignature] [NiceDefinition]-	    -- ^ A bunch of mutually recursive functions\/datatypes.-	    --   The last two lists have the same length. The first list is the-	    --   concrete declarations these definitions came from.-	| NiceModule Range Access IsAbstract QName Telescope [Declaration]-	| NiceModuleMacro Range Access IsAbstract Name Telescope Expr OpenShortHand ImportDirective-	| NiceOpen Range QName ImportDirective-	| NiceImport Range QName (Maybe AsName) OpenShortHand ImportDirective-	| NicePragma Range Pragma-    deriving (Typeable, Data)---- | A definition without its type signature.-data NiceDefinition-	= FunDef  Range [Declaration] Fixity' Access IsAbstract Name [Clause]-	| DataDef Range Fixity' Access IsAbstract Name [LamBinding] [NiceConstructor]-	| RecDef Range Fixity' Access IsAbstract Name (Maybe NiceConstructor) [LamBinding] [NiceDeclaration]-          -- ^ The 'NiceConstructor' has a dummy type field (the-          --   record constructor type has not been computed yet).-    deriving (Typeable, Data)+        | PrimitiveFunction Range Fixity' Access IsAbstract Name Expr+        | NiceMutual Range [NiceDeclaration]+        | NiceModule Range Access IsAbstract QName Telescope [Declaration]+        | NiceModuleMacro Range Access IsAbstract Name ModuleApplication OpenShortHand ImportDirective+        | NiceOpen Range QName ImportDirective+        | NiceImport Range QName (Maybe AsName) OpenShortHand ImportDirective+        | NicePragma Range Pragma+        | NiceRecSig Range Fixity' Access Name [LamBinding] Expr+        | NiceDataSig Range Fixity' Access Name [LamBinding] Expr+        | FunSig Range Fixity' Access Relevance Name Expr+        | FunDef  Range [Declaration] Fixity' IsAbstract Name [Clause] -- ^ block of function clauses (we have seen the type signature before)+        | DataDef Range Fixity' IsAbstract Name [LamBinding] [NiceConstructor]+        | RecDef Range Fixity' IsAbstract Name (Maybe (ThingWithFixity Name)) [LamBinding] [NiceDeclaration]+    deriving (Typeable, Data, Show)  -- | Only 'Axiom's. type NiceConstructor = NiceTypeSignature  -- | Only 'Axiom's.-type NiceTypeSignature	= NiceDeclaration+type NiceTypeSignature  = NiceDeclaration  -- | One clause in a function definition. There is no guarantee that the 'LHS' --   actually declares the 'Name'. We will have to check that later. data Clause = Clause Name LHS RHS WhereClause [Clause]-    deriving (Typeable, Data)+    deriving (Typeable, Data, Show)  -- | The exception type. data DeclarationException-	= MultipleFixityDecls [(Name, [Fixity'])]-	| MissingDefinition Name+        = MultipleFixityDecls [(Name, [Fixity'])]+        | MissingDefinition Name         | MissingWithClauses Name-	| MissingTypeSignature LHS-	| NotAllowedInMutual NiceDeclaration-	| UnknownNamesInFixityDecl [Name]+        | MissingTypeSignature LHS+        | MissingDataSignature Name+        | NotAllowedInMutual NiceDeclaration+        | UnknownNamesInFixityDecl [Name]         | Codata Range-	| DeclarationPanic String+        | DeclarationPanic String+        | UselessPrivate Range+        | UselessAbstract Range+        | AmbiguousFunClauses LHS [Name] -- ^ in a mutual block, a clause could belong to any of the @[Name]@ type signatures     deriving (Typeable)  instance HasRange DeclarationException where-    getRange (MultipleFixityDecls xs)	   = getRange (fst $ head xs)-    getRange (MissingDefinition x)	   = getRange x+    getRange (MultipleFixityDecls xs)      = getRange (fst $ head xs)+    getRange (MissingDefinition x)         = getRange x     getRange (MissingWithClauses x)        = getRange x-    getRange (MissingTypeSignature x)	   = getRange x-    getRange (NotAllowedInMutual x)	   = getRange x+    getRange (MissingTypeSignature x)      = getRange x+    getRange (MissingDataSignature x)      = getRange x+    getRange (AmbiguousFunClauses lhs xs)  = getRange lhs+    getRange (NotAllowedInMutual x)        = getRange x     getRange (UnknownNamesInFixityDecl xs) = getRange . head $ xs     getRange (Codata r)                    = r-    getRange (DeclarationPanic _)	   = noRange+    getRange (DeclarationPanic _)          = noRange+    getRange (UselessPrivate r)            = r+    getRange (UselessAbstract r)           = r  instance HasRange NiceDeclaration where-    getRange (Axiom r _ _ _ _ _ _)	       = r-    getRange (NiceField r _ _ _ _ _)	       = r-    getRange (NiceDef r _ _ _)		       = r-    getRange (NiceModule r _ _ _ _ _)	       = r-    getRange (NiceModuleMacro r _ _ _ _ _ _ _) = r-    getRange (NiceOpen r _ _)		       = r-    getRange (NiceImport r _ _ _ _)	       = r-    getRange (NicePragma r _)		       = r-    getRange (PrimitiveFunction r _ _ _ _ _)   = r--instance HasRange NiceDefinition where-  getRange (FunDef r _ _ _ _ _ _)   = r-  getRange (DataDef r _ _ _ _ _ _)  = r-  getRange (RecDef r _ _ _ _ _ _ _) = r+  getRange (Axiom r _ _ _ _ _)             = r+  getRange (NiceField r _ _ _ _ _)         = r+  getRange (NiceMutual r _)                = r+  getRange (NiceModule r _ _ _ _ _)        = r+  getRange (NiceModuleMacro r _ _ _ _ _ _) = r+  getRange (NiceOpen r _ _)                = r+  getRange (NiceImport r _ _ _ _)          = r+  getRange (NicePragma r _)                = r+  getRange (PrimitiveFunction r _ _ _ _ _) = r+  getRange (FunSig r _ _ _ _ _)            = r+  getRange (FunDef r _ _ _ _ _)            = r+  getRange (DataDef r _ _ _ _ _)           = r+  getRange (RecDef r _ _ _ _ _ _)          = r+  getRange (NiceRecSig r _ _ _ _ _)        = r+  getRange (NiceDataSig r _ _ _ _ _)       = r  instance Error DeclarationException where   noMsg  = strMsg ""@@ -121,30 +135,40 @@ instance Show DeclarationException where   show (MultipleFixityDecls xs) = show $     sep [ fsep $ pwords "Multiple fixity declarations for"-	, vcat $ map f xs-	]+        , vcat $ map f xs+        ]       where-	f (x, fs) = pretty x <> text ":" <+> fsep (map (text . show) fs)+        f (x, fs) = pretty x <> text ":" <+> fsep (map (text . show) fs)   show (MissingDefinition x) = show $ fsep $     pwords "Missing definition for" ++ [pretty x]   show (MissingWithClauses x) = show $ fsep $     pwords "Missing with-clauses for function" ++ [pretty x]   show (MissingTypeSignature x) = show $ fsep $     pwords "Missing type signature for left hand side" ++ [pretty x]+  show (MissingDataSignature x) = show $ fsep $+    pwords "Missing type signature for " ++ [pretty x]+  show (AmbiguousFunClauses lhs xs) = show $ fsep $+    pwords "More than one matching type signature for left hand side" ++ [pretty lhs] +++    pwords "it could belong to any of:" ++ map pretty xs   show (UnknownNamesInFixityDecl xs) = show $ fsep $     pwords "Names out of scope in fixity declarations:" ++ map pretty xs+  show (UselessPrivate _)      = show $ fsep $+    pwords "Using private here has no effect. Move it to the type signatures to make the definitions private."+  show (UselessAbstract _)      = show $ fsep $+    pwords "Using abstract here has no effect. Move it to the definitions to make them abstract."   show (NotAllowedInMutual nd) = show $ fsep $     [text $ decl nd] ++ pwords "are not allowed in mutual blocks"     where-      decl (Axiom{})		 = "Postulates"+      decl (Axiom{})             = "Postulates"       decl (NiceField{})         = "Fields"-      decl (NiceDef{})		 = "Record types"-      decl (NiceModule{})	 = "Modules"+      decl (NiceMutual{})        = "Mutual blocks"+      decl (NiceModule{})        = "Modules"       decl (NiceModuleMacro{})   = "Modules"-      decl (NiceOpen{})		 = "Open declarations"-      decl (NiceImport{})	 = "Import statements"-      decl (NicePragma{})	 = "Pragmas"+      decl (NiceOpen{})          = "Open declarations"+      decl (NiceImport{})        = "Import statements"+      decl (NicePragma{})        = "Pragmas"       decl (PrimitiveFunction{}) = "Primitive declarations"+      decl _ = __IMPOSSIBLE__   show (Codata _) =     "The codata construction has been removed. " ++     "Use the INFINITY builtin instead."@@ -154,304 +178,447 @@     The niceifier  --------------------------------------------------------------------------} -type Nice = Either DeclarationException+data InMutual+  = InMutual    -- ^ we are nicifying a mutual block+  | NotInMutual -- ^ we are nicifying decls not in a mutual block+    deriving (Eq, Show) -runNice :: Nice a -> Either DeclarationException a-runNice = id+data DataRecOrFun = DataName | RecName | FunName+  deriving (Eq, Ord) -niceDeclarations :: [Declaration] -> Nice [NiceDeclaration]-niceDeclarations ds = do-      fixs <- fixities ds-      case Map.keys fixs \\ concatMap declaredNames ds of-	[]  -> nice fixs ds-	xs  -> throwError $ UnknownNamesInFixityDecl xs-    where+data NiceEnv = NiceEnv+  { loneSigs :: [(DataRecOrFun, Name)]   -- ^ lone type signatures that wait for their fun.clauses+  , fixs     :: Map Name Fixity'+  } -	-- If no fixity is given we return the default fixity.-	fixity :: Name -> Map.Map Name Fixity' -> Fixity'-	fixity = Map.findWithDefault defaultFixity'+initNiceEnv :: NiceEnv+initNiceEnv = NiceEnv+  { loneSigs = []+  , fixs     = Map.empty+  } -	-- We forget all fixities in recursive calls. This is because-	-- fixity declarations have to appear at the same level as the-	-- declaration.-	fmapNice x = mapM niceDeclarations x+type Nice = StateT NiceEnv (Either DeclarationException) -	-- Compute the names defined in a declaration-	declaredNames :: Declaration -> [Name]-	declaredNames d = case d of-	  TypeSig _ x _				       -> [x]-          Field x _                                    -> [x]-	  FunClause (LHS p [] _ _) _ _-            | IdentP (QName x) <- noSingletonRawAppP p -> [x]-	  FunClause{}				       -> []-	  Data _ _ x _ _ cs			       -> x : concatMap declaredNames cs-	  Record _ x c _ _ _			       -> x : maybeToList c-	  Infix _ _				       -> []-          Syntax _ _                                   -> []-	  Mutual _ ds				       -> concatMap declaredNames ds-	  Abstract _ ds				       -> concatMap declaredNames ds-	  Private _ ds				       -> concatMap declaredNames ds-	  Postulate _ ds			       -> concatMap declaredNames ds-	  Primitive _ ds			       -> concatMap declaredNames ds-	  Open{}				       -> []-	  Import{}				       -> []-	  ModuleMacro{}				       -> []-	  Module{}				       -> []-	  Pragma{}				       -> []+localState :: Nice a -> Nice a+localState m = bracket get put (const m) -        niceFix fixs ds = do-	  fixs <- plusFixities fixs =<< fixities ds-          nice fixs ds+addLoneSig :: DataRecOrFun -> Name -> Nice ()+addLoneSig k x = modify $ \ niceEnv -> niceEnv { loneSigs = (k, x) : loneSigs niceEnv } -	nice _ []	 = return []-	nice fixs (d:ds) =-	    case d of-		TypeSig rel x t ->-		    -- After a type signature there should follow a bunch of-		    -- clauses.-		    case span (isFunClauseOf x) ds of-			([], _)	    -> throwError $ MissingDefinition x-			(ds0,ds1)   -> do-			  ds1 <- nice fixs ds1-			  d <- mkFunDef rel fixs x (Just t) ds0-                          return $ d : ds1+removeLoneSig :: DataRecOrFun -> Name -> Nice ()+removeLoneSig k x = modify $ \ niceEnv -> niceEnv { loneSigs = delete (k, x) $ loneSigs niceEnv } -		cl@(FunClause lhs@(LHS p [] _ _) _ _)-                  | IdentP (QName x) <- noSingletonRawAppP p-                                  -> do-		      ds <- nice fixs ds-		      d <- mkFunDef Relevant fixs x Nothing [cl] -- fun def without type signature is relevant-                      return $ d : ds-                FunClause lhs _ _ -> throwError $ MissingTypeSignature lhs+hasSig :: DataRecOrFun -> Name -> Nice Bool+hasSig k x = gets $ elem (k, x) . loneSigs -		_   -> liftM2 (++) nds (nice fixs ds)-		    where-			nds = case d of-                            Field x t                     -> return $ niceAxioms fixs [ d ]-			    Data r CoInductive x tel t cs -> throwError (Codata r)-			    Data r Inductive   x tel t cs -> dataOrRec DataDef niceAx r x tel t cs-			    Record r x c tel t cs         -> do-                              let c' = (\c -> niceAxiom fixs (TypeSig Relevant c t)) <$> c -- constructor is always relevant-                              dataOrRec (\x1 x2 x3 x4 x5 -> RecDef x1 x2 x3 x4 x5 c')-                                        (const niceDeclarations) r x tel t cs-			    Mutual r ds -> do-			      d <- mkMutual r [d] =<< niceFix fixs ds-			      return [d]+noLoneSigs :: Nice Bool+noLoneSigs = gets $ null . loneSigs -			    Abstract r ds -> do-			      map mkAbstract <$> niceFix fixs ds+checkLoneSigs :: Nice ()+checkLoneSigs = do+  xs <- gets loneSigs+  case xs of+    []       -> return ()+    (_, x):_ -> throwError $ MissingDefinition x -			    Private _ ds -> do-			      map mkPrivate <$> niceFix fixs ds+getFixity :: Name -> Nice Fixity'+getFixity x = gets $ Map.findWithDefault defaultFixity' x . fixs -			    Postulate _ ds -> return $ niceAxioms fixs ds+runNice :: Nice a -> Either DeclarationException a+runNice nice = nice `evalStateT` initNiceEnv -			    Primitive _ ds -> return $ map toPrim $ niceAxioms fixs ds+data DeclKind = LoneSig DataRecOrFun Name | LoneDef DataRecOrFun Name | OtherDecl -			    Module r x tel ds	-> return-				[ NiceModule r PublicAccess ConcreteDef x tel ds ]+declKind (FunSig _ _ _ _ x _)      = LoneSig FunName x+declKind (NiceRecSig _ _ _ x _ _)  = LoneSig RecName x+declKind (NiceDataSig _ _ _ x _ _) = LoneSig DataName x+declKind (FunDef _ _ _ _ x _)      = LoneDef FunName x+declKind (DataDef _ _ _ x _ _)     = LoneDef DataName x+declKind (RecDef _ _ _ x _ _ _)    = LoneDef RecName x+declKind _                         = OtherDecl -			    ModuleMacro r x tel e op is -> return-				[ NiceModuleMacro r PublicAccess ConcreteDef x tel e op is ]+niceDeclarations :: [Declaration] -> Nice [NiceDeclaration]+niceDeclarations ds = do+  fixs <- fixities ds+  case Map.keys fixs \\ concatMap declaredNames ds of+    []  -> localState $ do+      put $ initNiceEnv { fixs = fixs }+      ds <- nice ds+      checkLoneSigs+      modify $ \s -> s { loneSigs = [] }+      inferMutualBlocks ds+    xs  -> throwError $ UnknownNamesInFixityDecl xs+  where+    -- Compute the names defined in a declaration+    declaredNames :: Declaration -> [Name]+    declaredNames d = case d of+      TypeSig _ x _                                -> [x]+      Field x _                                    -> [x]+      FunClause (LHS p [] _ _) _ _+        | IdentP (QName x) <- removeSingletonRawAppP p -> [x]+      FunClause{}                                  -> []+      DataSig _ _ x _ _                            -> [x]+      Data _ _ x _ _ cs                            -> x : concatMap declaredNames cs+      RecordSig _ x _ _                            -> [x]+      Record _ x c _ _ _                           -> x : foldMap (:[]) c+      Infix _ _                                    -> []+      Syntax _ _                                   -> []+      Mutual _ ds                                  -> concatMap declaredNames ds+      Abstract _ ds                                -> concatMap declaredNames ds+      Private _ ds                                 -> concatMap declaredNames ds+      Postulate _ ds                               -> concatMap declaredNames ds+      Primitive _ ds                               -> concatMap declaredNames ds+      Open{}                                       -> []+      Import{}                                     -> []+      ModuleMacro{}                                -> []+      Module{}                                     -> []+      Pragma{}                                     -> [] -			    Infix _ _		-> return []-			    Syntax _ _		-> return []-			    Open r x is		-> return [NiceOpen r x is]-			    Import r x as op is	-> return [NiceImport r x as op is]+    inferMutualBlocks :: [NiceDeclaration] -> Nice [NiceDeclaration]+    inferMutualBlocks [] = return []+    inferMutualBlocks (d : ds) =+      case declKind d of+        OtherDecl   -> (d :) <$> inferMutualBlocks ds+        LoneDef _ x -> __IMPOSSIBLE__+        LoneSig k x -> do+          addLoneSig k x+          (ds0, ds1) <- untilAllDefined ds+          (NiceMutual (getRange (d : ds0)) (d : ds0) :) <$> inferMutualBlocks ds1+      where+        untilAllDefined ds = do+          done <- noLoneSigs+          if done then return ([], ds) else+            case ds of+              []     -> __IMPOSSIBLE__ <$ checkLoneSigs+              d : ds -> case declKind d of+                LoneSig k x -> addLoneSig    k x >> cons d (untilAllDefined ds)+                LoneDef k x -> removeLoneSig k x >> cons d (untilAllDefined ds)+                OtherDecl   -> cons d (untilAllDefined ds)+          where+            cons d = fmap ((d :) *** id) -			    Pragma p		-> return [NicePragma (getRange p) p]+    nice :: [Declaration] -> Nice [NiceDeclaration]+    nice [] = return []+    nice (d:ds) = do+      case d of+        TypeSig rel x t -> do+           fx <- getFixity x+           -- register x as lone type signature, to recognize clauses later+           addLoneSig FunName x+           ds <- nice ds+           return $ FunSig (getRange d) fx PublicAccess rel x t : ds+        cl@(FunClause lhs _ _) -> do+          xs <- gets $ map snd . filter ((== FunName) . fst) . loneSigs+          -- for each type signature 'x' waiting for clauses, we try+          -- if we have some clauses for 'x'+          fixs <- gets fixs+          case filter (\ (x,(fits,rest)) -> not $ null fits) $+                  map (\ x -> (x, span (couldBeFunClauseOf (Map.lookup x fixs) x) $ d : ds)) xs of+            -- case: clauses match none of the sigs+            -- treat it as a function clause without a type signature+            [] -> case lhs of+              LHS p [] _ _ | IdentP (QName x) <- removeSingletonRawAppP p -> do+                ds <- nice ds+                d  <- mkFunDef Relevant x Nothing [cl] -- fun def without type signature is relevant+                return $ d ++ ds+              _ -> throwError $ MissingTypeSignature lhs+            -- case: clauses match exactly one of the sigs+            [(x,(fits,rest))] -> do+               removeLoneSig FunName x+               cs  <- mkClauses x $ expandEllipsis fits+               ds1 <- nice rest+               fx  <- getFixity x+               d   <- return $ FunDef (getRange fits) fits fx ConcreteDef x cs+               return $ d : ds1+            -- case: clauses match more than one sigs (ambiguity)+            l -> throwError $ AmbiguousFunClauses lhs (map fst l) -- "ambiguous function clause; cannot assign it uniquely to one type signature" -			    FunClause _ _ _	-> __IMPOSSIBLE__-			    TypeSig{}		-> __IMPOSSIBLE__-			  where-			    dataOrRec mkDef niceD r x tel t cs = do-                              ds <- niceD fixs cs-                              return $-                                [ NiceDef r [d]-                                  [ Axiom (fuseRange x t) f PublicAccess ConcreteDef Relevant-                                          x (Pi tel t)-                                  ]-                                  -- Setting the range to the range of t makes sense-                                  -- since the only errors you get at the level of the-                                  -- definitions are the type not ending in a sort.-                                  [ mkDef (getRange t) f PublicAccess ConcreteDef x-                                          (concatMap binding tel)-                                          ds-                                  ]-                                ]-                              where-                                f = fixity x fixs-                                binding (TypedBindings _ (Arg h rel bs)) =-                                    concatMap (bind h) bs-                                bind h (TBind _ xs _) =-                                    map (DomainFree h) xs-                                bind h (TNoBind e) =-                                    [ DomainFree h $ mkBoundName_ (noName (getRange e)) ]+        Field x t                     -> (++) <$> niceAxioms [ d ] <*> nice ds+        DataSig r CoInductive x tel t -> throwError (Codata r)+        Data r CoInductive x tel t cs -> throwError (Codata r)+        DataSig r Inductive   x tel t -> do+          addLoneSig DataName x+          (++) <$> dataOrRec DataDef NiceDataSig niceAxioms r x tel (Just t) Nothing+               <*> nice ds+        Data r Inductive x tel t cs -> do+          t <- defaultTypeSig DataName x t+          (++) <$> dataOrRec DataDef NiceDataSig niceAxioms r x tel t (Just cs)+               <*> nice ds+        RecordSig r x tel t -> do+          addLoneSig RecName x+          fx <- getFixity x+          (NiceRecSig r fx PublicAccess x tel t :) <$> nice ds+        Record r x c tel t cs -> do+          t <- defaultTypeSig RecName x t+          c <- traverse (\c -> ThingWithFixity c <$> getFixity c) c+          (++) <$> dataOrRec (\x1 x2 x3 x4 -> RecDef x1 x2 x3 x4 c) NiceRecSig+                             niceDeclarations r x tel t (Just cs)+               <*> nice ds+        Mutual r ds' ->+          (:) <$> (mkOldMutual r =<< nice ds') <*> nice ds +        Abstract r ds' ->+          (++) <$> (abstractBlock r =<< nice ds') <*> nice ds +        Private r ds' ->+          (++) <$> (privateBlock r =<< nice ds') <*> nice ds -	-- Translate axioms-        niceAx fixs ds = return $ niceAxioms fixs ds+        Postulate _ ds' -> (++) <$> niceAxioms ds' <*> nice ds -	niceAxioms :: Map.Map Name Fixity' -> [TypeSignature] -> [NiceDeclaration]-	niceAxioms fixs ds = map (niceAxiom fixs) ds+        Primitive _ ds' -> (++) <$> (map toPrim <$> niceAxioms ds') <*> nice ds -        niceAxiom :: Map.Map Name Fixity' -> TypeSignature -> NiceDeclaration-        niceAxiom fixs d@(TypeSig rel x t) =-            Axiom (getRange d) (fixity x fixs) PublicAccess ConcreteDef rel x t-        niceAxiom fixs d@(Field x argt) =-            NiceField (getRange d) (fixity x fixs) PublicAccess ConcreteDef x argt-        niceAxiom _ _ = __IMPOSSIBLE__+        Module r x tel ds' ->+          (NiceModule r PublicAccess ConcreteDef x tel ds' :) <$> nice ds -	toPrim :: NiceDeclaration -> NiceDeclaration-	toPrim (Axiom r f a c rel x t) = PrimitiveFunction r f a c x t-	toPrim _		       = __IMPOSSIBLE__+        ModuleMacro r x modapp op is ->+          (NiceModuleMacro r PublicAccess ConcreteDef x modapp op is :)+            <$> nice ds -	-- Create a function definition.-	mkFunDef rel fixs x mt ds0 = do-          cs <- mkClauses x $ expandEllipsis ds0-          return $-	    NiceDef (fuseRange x ds0)-		    (TypeSig rel x t : ds0)-		    [ Axiom (fuseRange x t) f PublicAccess ConcreteDef rel x t ]-		    [ FunDef (getRange ds0) ds0 f PublicAccess ConcreteDef x cs-		    ]-	    where-	      f = fixity x fixs-	      t = case mt of-		    Just t  -> t-		    Nothing -> Underscore (getRange x) Nothing+        Infix _ _           -> nice ds+        Syntax _ _          -> nice ds+        Open r x is         -> (NiceOpen r x is :) <$> nice ds+        Import r x as op is -> (NiceImport r x as op is :) <$> nice ds +        Pragma p            -> (NicePragma (getRange p) p :) <$> nice ds -        expandEllipsis :: [Declaration] -> [Declaration]-        expandEllipsis [] = []-        expandEllipsis (d@(FunClause Ellipsis{} _ _) : ds) =-          d : expandEllipsis ds-        expandEllipsis (d@(FunClause lhs@(LHS p ps _ _) _ _) : ds) =+    -- We could add a default type signature here, but at the moment we can't+    -- infer the type of a record or datatype, so better to just fail here.+    defaultTypeSig k x t@Just{} = return t+    defaultTypeSig k x Nothing  =+      ifM (hasSig k x)+          (Nothing <$ removeLoneSig k x)+          (throwError $ MissingDataSignature x)++    dataOrRec mkDef mkSig niceD r x tel mt mcs = do+      mds <- traverse niceD mcs+      f   <- getFixity x+      return $+         [mkSig (fuseRange x t) f PublicAccess x tel t | Just t <- [mt] ] +++         [mkDef (getRange x) f ConcreteDef x (concatMap dropType tel) ds | Just ds <- [mds] ]+      where+        dropType (DomainFull (TypedBindings r (Arg h rel TNoBind{}))) =+          [DomainFree h rel $ mkBoundName_ $ noName r]+        dropType (DomainFull (TypedBindings r (Arg h rel (TBind _ xs _)))) =+          map (DomainFree h rel) xs+        dropType b@DomainFree{} = [b]++    -- Translate axioms+    niceAxioms :: [TypeSignature] -> Nice [NiceDeclaration]+    niceAxioms ds = mapM niceAxiom ds++    niceAxiom :: TypeSignature -> Nice NiceDeclaration+    niceAxiom d@(TypeSig rel x t) = do+      fx <- getFixity x+      return $ Axiom (getRange d) fx PublicAccess rel x t+    niceAxiom d@(Field x argt) = do+      fx <- getFixity x+      return $ NiceField (getRange d) fx PublicAccess ConcreteDef x argt+    niceAxiom _ = __IMPOSSIBLE__++    toPrim :: NiceDeclaration -> NiceDeclaration+    toPrim (Axiom r f a rel x t) = PrimitiveFunction r f a ConcreteDef x t+    toPrim _                     = __IMPOSSIBLE__++    -- Create a function definition.+    mkFunDef rel x mt ds0 = do+      cs <- mkClauses x $ expandEllipsis ds0+      f  <- getFixity x+      return [ FunSig (fuseRange x t) f PublicAccess rel x t+             , FunDef (getRange ds0) ds0 f ConcreteDef x cs ]+        where+          t = case mt of+                Just t  -> t+                Nothing -> underscore (getRange x)++    underscore r = Underscore r Nothing+++    expandEllipsis :: [Declaration] -> [Declaration]+    expandEllipsis [] = []+    expandEllipsis (d@(FunClause Ellipsis{} _ _) : ds) =+      d : expandEllipsis ds+    expandEllipsis (d@(FunClause lhs@(LHS p ps _ _) _ _) : ds) =+      d : expand p ps ds+      where+        expand _ _ [] = []+        expand p ps (FunClause (Ellipsis _ ps' eqs []) rhs wh : ds) =+          FunClause (LHS p (ps ++ ps') eqs []) rhs wh : expand p ps ds+        expand p ps (FunClause (Ellipsis _ ps' eqs es) rhs wh : ds) =+          FunClause (LHS p (ps ++ ps') eqs es) rhs wh : expand p (ps ++ ps') ds+        expand p ps (d@(FunClause (LHS _ _ _ []) _ _) : ds) =           d : expand p ps ds-          where-            expand _ _ [] = []-            expand p ps (FunClause (Ellipsis _ ps' eqs []) rhs wh : ds) =-              FunClause (LHS p (ps ++ ps') eqs []) rhs wh : expand p ps ds-            expand p ps (FunClause (Ellipsis _ ps' eqs es) rhs wh : ds) =-              FunClause (LHS p (ps ++ ps') eqs es) rhs wh : expand p (ps ++ ps') ds-            expand p ps (d@(FunClause (LHS _ _ _ []) _ _) : ds) =-              d : expand p ps ds-            expand _ _ (d@(FunClause (LHS p ps _ (_ : _)) _ _) : ds) =-              d : expand p ps ds-            expand _ _ (_ : ds) = __IMPOSSIBLE__-        expandEllipsis (_ : ds) = __IMPOSSIBLE__+        expand _ _ (d@(FunClause (LHS p ps _ (_ : _)) _ _) : ds) =+          d : expand p ps ds+        expand _ _ (_ : ds) = __IMPOSSIBLE__+    expandEllipsis (_ : ds) = __IMPOSSIBLE__  -        -- Turn function clauses into nice function clauses.-        mkClauses :: Name -> [Declaration] -> Nice [Clause]-        mkClauses _ [] = return []-        mkClauses x (FunClause lhs@(LHS _ _ _ []) rhs wh : cs) =-          (Clause x lhs rhs wh [] :) <$> mkClauses x cs-        mkClauses x (FunClause lhs@(LHS _ ps _ es) rhs wh : cs) = do-          when (null with) $ throwError $ MissingWithClauses x-          wcs <- mkClauses x with-          (Clause x lhs rhs wh wcs :) <$> mkClauses x cs'-          where-            (with, cs') = span subClause cs+    -- Turn function clauses into nice function clauses.+    mkClauses :: Name -> [Declaration] -> Nice [Clause]+    mkClauses _ [] = return []+    mkClauses x (FunClause lhs@(LHS _ _ _ []) rhs wh : cs) =+      (Clause x lhs rhs wh [] :) <$> mkClauses x cs+    mkClauses x (FunClause lhs@(LHS _ ps _ es) rhs wh : cs) = do+      when (null with) $ throwError $ MissingWithClauses x+      wcs <- mkClauses x with+      (Clause x lhs rhs wh wcs :) <$> mkClauses x cs'+      where+        (with, cs') = span subClause cs -            -- A clause is a subclause if the number of with-patterns is-            -- greater or equal to the current number of with-patterns plus the-            -- number of with arguments.-            subClause (FunClause (LHS _ ps' _ _) _ _)      =-              length ps' >= length ps + length es-            subClause (FunClause (Ellipsis _ ps' _ _) _ _) = True-            subClause _                                  = __IMPOSSIBLE__-        mkClauses x (FunClause lhs@Ellipsis{} rhs wh : cs) =-          (Clause x lhs rhs wh [] :) <$> mkClauses x cs   -- Will result in an error later.-        mkClauses _ _ = __IMPOSSIBLE__+        -- A clause is a subclause if the number of with-patterns is+        -- greater or equal to the current number of with-patterns plus the+        -- number of with arguments.+        subClause (FunClause (LHS _ ps' _ _) _ _)      =+          length ps' >= length ps + length es+        subClause (FunClause (Ellipsis _ ps' _ _) _ _) = True+        subClause _                                  = __IMPOSSIBLE__+    mkClauses x (FunClause lhs@Ellipsis{} rhs wh : cs) =+      (Clause x lhs rhs wh [] :) <$> mkClauses x cs   -- Will result in an error later.+    mkClauses _ _ = __IMPOSSIBLE__ -	noSingletonRawAppP (RawAppP _ [p]) = noSingletonRawAppP p-	noSingletonRawAppP p		   = p+    -- for finding clauses for a type sig in mutual blocks+    couldBeFunClauseOf :: Maybe Fixity' -> Name -> Declaration -> Bool+    couldBeFunClauseOf mFixity x (FunClause Ellipsis{} _ _) = True+    couldBeFunClauseOf mFixity x (FunClause (LHS p _ _ _) _ _) =+      let+      pns        = patternNames p+      xStrings   = nameStringParts x+      patStrings = concatMap nameStringParts pns+      in+--          trace ("x = " ++ show x) $+--          trace ("pns = " ++ show pns) $+--          trace ("xStrings = " ++ show xStrings) $+--          trace ("patStrings = " ++ show patStrings) $+--          trace ("mFixity = " ++ show mFixity) $+      case (mhead pns, mFixity) of+        -- first identifier in the patterns is the fun.symbol?+        (Just y, _) | x == y -> True -- trace ("couldBe since y = " ++ show y) $ True+        -- are the parts of x contained in p+        _ | xStrings `isSublistOf` patStrings -> True -- trace ("couldBe since isSublistOf") $ True+        -- looking for a mixfix fun.symb+        (_, Just fix) ->  -- also matches in case of a postfix+           let notStrings = stringParts (theNotation fix)+           in  -- trace ("notStrings = " ++ show notStrings) $+               -- trace ("patStrings = " ++ show patStrings) $+               (not $ null notStrings) && (notStrings `isSublistOf` patStrings)+        -- not a notation, not first id: give up+        _ -> False -- trace ("couldBe not (case default)") $ False+    couldBeFunClauseOf _ _ _ = False -- trace ("couldBe not (fun default)") $ False -        isFunClauseOf x (FunClause Ellipsis{} _ _) = True-	isFunClauseOf x (FunClause (LHS p _ _ _) _ _) = case noSingletonRawAppP p of-	    IdentP (QName q)	-> x == q-	    _			-> True-		-- more complicated lhss must come with type signatures, so we just assume-		-- it's part of the current definition-	isFunClauseOf _ _ = False+    -- @isFunClauseOf@ is for non-mutual blocks where clauses must follow the+    -- type sig immediately+    isFunClauseOf :: Name -> Declaration -> Bool+    isFunClauseOf x (FunClause Ellipsis{} _ _) = True+    isFunClauseOf x (FunClause (LHS p _ _ _) _ _) =+     -- p is the whole left hand side, excluding "with" patterns and clauses+      case removeSingletonRawAppP p of+        IdentP (QName q)    -> x == q+        _                   -> True+            -- more complicated lhss must come with type signatures, so we just assume+            -- it's part of the current definition+    isFunClauseOf _ _ = False -	-- Make a mutual declaration-	mkMutual :: Range -> [Declaration] -> [NiceDeclaration] -> Nice NiceDeclaration-	mkMutual r cs ds = do-            mapM_ checkMutual ds-            setConcrete cs <$> foldM smash (NiceDef r [] [] []) ds-	  where-            setConcrete cs (NiceDef r _ ts ds)  = NiceDef r cs ts ds-            setConcrete cs d		    = __IMPOSSIBLE__+    removeSingletonRawAppP :: Pattern -> Pattern+    removeSingletonRawAppP (RawAppP _ [p]) = removeSingletonRawAppP p+    removeSingletonRawAppP p               = p -            isRecord RecDef{} = True-            isRecord _	  = False+    -- Make an old style mutual block from a list of mutual declarations+    mkOldMutual :: Range -> [NiceDeclaration] -> Nice NiceDeclaration+    mkOldMutual r ds = do+        -- Check that there aren't any missing definitions+        case filter (`notElem` defNames) sigNames of+          []       -> return ()+          (_, x):_ -> throwError $ MissingDefinition x+        -- Check that there are no declarations that aren't allowed in old style mutual blocks+        case [ d | (d, OtherDecl) <- zip ds $ map declKind ds ] of+          []  -> return ()+          d:_ -> throwError $ NotAllowedInMutual d+        return $ NiceMutual r $ sigs ++ other+      where+        -- Pull type signatures to the top+        (sigs, other) = partition isTypeSig ds+        isTypeSig d | LoneSig{} <- declKind d = True+        isTypeSig _ = False -            checkMutual nd@(NiceDef _ _ _ ds)-              | any isRecord ds = throwError $ NotAllowedInMutual nd-              | otherwise       = return ()-            checkMutual d = throwError $ NotAllowedInMutual d+        sigNames = [ (k, x) | LoneSig k x <- map declKind ds ]+        defNames = [ (k, x) | LoneDef k x <- map declKind ds ] -            smash nd@(NiceDef r0 _ ts0 ds0) (NiceDef r1 _ ts1 ds1) =-              return $ NiceDef (fuseRange r0 r1) [] (ts0 ++ ts1) (ds0 ++ ds1)-            smash _ _ = __IMPOSSIBLE__+    abstractBlock _ [] = return []+    abstractBlock r ds+        -- hack to avoid failing on inherited abstract blocks in where clauses+      | r == noRange           = return $ map mkAbstract ds+      | all uselessAbstract ds = throwError $ UselessAbstract r+      | otherwise              = return $ map mkAbstract ds -	-- Make a declaration abstract-	mkAbstract d =-	    case d of-		Axiom r f a _ rel x e		    -> Axiom r f a AbstractDef rel x e-		NiceField r f a _ x e		    -> NiceField r f a AbstractDef x e-		PrimitiveFunction r f a _ x e	    -> PrimitiveFunction r f a AbstractDef x e-		NiceDef r cs ts ds		    -> NiceDef r cs (map mkAbstract ts)-								 (map mkAbstractDef ds)-		NiceModule r a _ x tel ds	    -> NiceModule r a AbstractDef x tel [ Abstract (getRange ds) ds ]-		NiceModuleMacro r a _ x tel e op is -> NiceModuleMacro r a AbstractDef x tel e op is-		NicePragma _ _			    -> d-		NiceOpen _ _ _			    -> d-		NiceImport _ _ _ _ _		    -> d+    uselessAbstract d = case d of+      FunDef{}  -> False+      DataDef{} -> False+      RecDef{}  -> False+      _         -> True -	mkAbstractDef d =-	    case d of-		FunDef r ds f a _ x cs   -> FunDef r ds f a AbstractDef x (map mkAbstractClause cs)-		DataDef r f a _ x ps cs  -> DataDef r f a AbstractDef x ps $ map mkAbstract cs-		RecDef r f a _ x c ps cs -> RecDef r f a AbstractDef x (mkAbstract <$> c) ps $ map mkAbstract cs+    privateBlock _ [] = return []+    privateBlock r ds+      | all uselessPrivate ds = throwError $ UselessPrivate r+      | otherwise             = return $ map mkPrivate ds -	mkAbstractClause (Clause x lhs rhs wh with) =-	    Clause x lhs rhs (mkAbstractWhere wh) (map mkAbstractClause with)+    uselessPrivate d = case d of+      FunDef{}  -> True+      DataDef{} -> True+      RecDef{}  -> True+      _         -> False -	mkAbstractWhere  NoWhere	 = NoWhere-	mkAbstractWhere (AnyWhere ds)	 = AnyWhere [Abstract (getRange ds) ds]-	mkAbstractWhere (SomeWhere m ds) = SomeWhere m [Abstract (getRange ds) ds]+    -- Make a declaration abstract+    mkAbstract d =+        case d of+            NiceField r f a _ x e            -> NiceField r f a AbstractDef x e+            PrimitiveFunction r f a _ x e    -> PrimitiveFunction r f a AbstractDef x e+            NiceMutual r ds                  -> NiceMutual r (map mkAbstract ds)+            NiceModuleMacro r a _ x ma op is -> NiceModuleMacro r a AbstractDef x ma op is+            FunDef r ds f _ x cs             -> FunDef r ds f AbstractDef x (map mkAbstractClause cs)+            DataDef r f _ x ps cs            -> DataDef r f AbstractDef x ps $ map mkAbstract cs+            RecDef r f _ x c ps cs           -> RecDef r f AbstractDef x c ps $ map mkAbstract cs+            NiceModule{}                     -> d+            Axiom{}                          -> d+            NicePragma{}                     -> d+            NiceOpen{}                       -> d+            NiceImport{}                     -> d+            FunSig{}                         -> d+            NiceRecSig{}                     -> d+            NiceDataSig{}                    -> d -	-- Make a declaration private-	mkPrivate d =-	    case d of-		Axiom r f _ a rel x e		    -> Axiom r f PrivateAccess a rel x e-		NiceField r f _ a x e		    -> NiceField r f PrivateAccess a x e-		PrimitiveFunction r f _ a x e	    -> PrimitiveFunction r f PrivateAccess a x e-		NiceDef r cs ts ds		    -> NiceDef r cs (map mkPrivate ts)-								    (map mkPrivateDef ds)-		NiceModule r _ a x tel ds	    -> NiceModule r PrivateAccess a x tel ds-		NiceModuleMacro r _ a x tel e op is -> NiceModuleMacro r PrivateAccess a x tel e op is-		NicePragma _ _			    -> d-		NiceOpen _ _ _			    -> d-		NiceImport _ _ _ _ _		    -> d+    mkAbstractClause (Clause x lhs rhs wh with) =+        Clause x lhs rhs (mkAbstractWhere wh) (map mkAbstractClause with) -	mkPrivateDef d =-	    case d of-		FunDef r ds f _ a x cs   -> FunDef r ds f PrivateAccess a x (map mkPrivateClause cs)-		DataDef r f _ a x ps cs  -> DataDef r f PrivateAccess a x ps (map mkPrivate cs)-		RecDef r f _ a x c ps cs -> RecDef r f PrivateAccess a x (mkPrivate <$> c) ps cs+    mkAbstractWhere  NoWhere         = NoWhere+    mkAbstractWhere (AnyWhere ds)    = AnyWhere [Abstract noRange ds]+    mkAbstractWhere (SomeWhere m ds) = SomeWhere m [Abstract noRange ds] -	mkPrivateClause (Clause x lhs rhs wh with) =-	    Clause x lhs rhs (mkPrivateWhere wh) (map mkPrivateClause with)+    -- Make a declaration private+    mkPrivate d =+        case d of+            Axiom r f _ rel x e              -> Axiom r f PrivateAccess rel x e+            NiceField r f _ a x e            -> NiceField r f PrivateAccess a x e+            PrimitiveFunction r f _ a x e    -> PrimitiveFunction r f PrivateAccess a x e+            NiceMutual r ds                  -> NiceMutual r (map mkPrivate ds)+            NiceModule r _ a x tel ds        -> NiceModule r PrivateAccess a x tel ds+            NiceModuleMacro r _ a x ma op is -> NiceModuleMacro r PrivateAccess a x ma op is+            FunSig r f _ rel x e           -> FunSig r f PrivateAccess rel x e+            NiceRecSig r f _ x ls t        -> NiceRecSig r f PrivateAccess x ls t+            NiceDataSig r f _ x ls t       -> NiceDataSig r f PrivateAccess x ls t+            NicePragma _ _                   -> d+            NiceOpen _ _ _                   -> d+            NiceImport _ _ _ _ _             -> d+            FunDef{}                         -> d+            DataDef{}                        -> d+            RecDef{}                         -> d -	mkPrivateWhere  NoWhere		= NoWhere-	mkPrivateWhere (AnyWhere ds)	= AnyWhere [Private (getRange ds) ds]-	mkPrivateWhere (SomeWhere m ds) = SomeWhere m [Private (getRange ds) ds]+    mkPrivateClause (Clause x lhs rhs wh with) =+        Clause x lhs rhs (mkPrivateWhere wh) (map mkPrivateClause with) +    mkPrivateWhere  NoWhere         = NoWhere+    mkPrivateWhere (AnyWhere ds)    = AnyWhere [Private (getRange ds) ds]+    mkPrivateWhere (SomeWhere m ds) = SomeWhere m [Private (getRange ds) ds]+ -- | Add more fixities. Throw an exception for multiple fixity declarations. plusFixities :: Map.Map Name Fixity' -> Map.Map Name Fixity' -> Nice (Map.Map Name Fixity') plusFixities m1 m2@@ -464,10 +631,10 @@                     s | s1 == noNotation = s2                       | s2 == noNotation = s1                       | otherwise = __IMPOSSIBLE__- 	  isect	= [decls x | (x,compat) <- Map.assocs (Map.intersectionWith compatible m1 m2), not compat]+          isect = [decls x | (x,compat) <- Map.assocs (Map.intersectionWith compatible m1 m2), not compat] -	  decls x = (x, map (Map.findWithDefault __IMPOSSIBLE__ x) [m1,m2])-				-- cpp doesn't know about primes+          decls x = (x, map (Map.findWithDefault __IMPOSSIBLE__ x) [m1,m2])+                                -- cpp doesn't know about primes           compatible (Fixity' f1 s1) (Fixity' f2 s2) = (f1 == noFixity || f2 == noFixity) &&                                                        (s1 == noNotation || s2 == noNotation) @@ -477,21 +644,31 @@ --   declaration. fixities :: [Declaration] -> Nice (Map.Map Name Fixity') fixities (d:ds) = case d of-  Syntax x syn -> do fs <- fixities ds-                     plusFixities fs (Map.singleton x (Fixity' noFixity syn))-  Infix f xs -> plusFixities (Map.fromList [ (x,Fixity' f noNotation) | x <- xs ]) =<< fixities ds-  _          -> fixities ds+  Syntax x syn   -> plusFixities (Map.singleton x (Fixity' noFixity syn)) =<< fixities ds+  Infix f xs     -> plusFixities (Map.fromList [ (x,Fixity' f noNotation) | x <- xs ]) =<< fixities ds+  Mutual _ ds'   -> fixities (ds' ++ ds)+  Abstract _ ds' -> fixities (ds' ++ ds)+  Private _ ds'  -> fixities (ds' ++ ds)+  _              -> fixities ds fixities [] = return $ Map.empty  notSoNiceDeclarations :: [NiceDeclaration] -> [Declaration] notSoNiceDeclarations = concatMap notNice   where-    notNice (Axiom _ _ _ _ rel x e)               = [TypeSig rel x e]-    notNice (NiceField _ _ _ _ x argt)            = [Field x argt]-    notNice (PrimitiveFunction r _ _ _ x e)       = [Primitive r [TypeSig Relevant x e]]-    notNice (NiceDef _ ds _ _)                    = ds-    notNice (NiceModule r _ _ x tel ds)           = [Module r x tel ds]-    notNice (NiceModuleMacro r _ _ x tel e o dir) = [ModuleMacro r x tel e o dir]-    notNice (NiceOpen r x dir)                    = [Open r x dir]-    notNice (NiceImport r x as o dir)             = [Import r x as o dir]-    notNice (NicePragma _ p)                      = [Pragma p]+    notNice d = case d of+      Axiom _ _ _ rel x e              -> [TypeSig rel x e]+      NiceField _ _ _ _ x argt         -> [Field x argt]+      PrimitiveFunction r _ _ _ x e    -> [Primitive r [TypeSig Relevant x e]]+      NiceMutual _ ds                  -> concatMap notNice ds+      NiceModule r _ _ x tel ds        -> [Module r x tel ds]+      NiceModuleMacro r _ _ x ma o dir -> [ModuleMacro r x ma o dir]+      NiceOpen r x dir                 -> [Open r x dir]+      NiceImport r x as o dir          -> [Import r x as o dir]+      NicePragma _ p                   -> [Pragma p]+      NiceRecSig r _ _ x bs e          -> [RecordSig r x bs e]+      NiceDataSig r _ _ x bs e         -> [DataSig r Inductive x bs e]+      FunSig _ _ _ rel x e             -> [TypeSig rel x e]+      FunDef _ ds _ _ _ _              -> ds+      DataDef r _ _ x bs cs            -> [Data r Inductive x bs Nothing $ concatMap notNice cs]+      RecDef r _ _ x c bs ds           -> [Record r x (unThing <$> c) bs Nothing $ concatMap notNice ds]+        where unThing (ThingWithFixity c _) = c

src/full/Agda/Syntax/Concrete/Name.hs view

@@ -49,6 +49,7 @@ isNoName :: Name -> Bool isNoName (NoName _ _)    = True isNoName (Name _ [Hole]) = True   -- TODO: Track down where these come from+isNoName (Name _ [])     = True isNoName _               = False  -- | Is the name an operator?@@ -60,6 +61,9 @@ nameParts :: Name -> [NamePart] nameParts (Name _ ps)  = ps nameParts (NoName _ _) = [Hole]++nameStringParts :: Name -> [String]+nameStringParts n = [ s | Id s <- nameParts n ]  -- | @qualify A.B x == A.B.x@ qualify :: QName -> Name -> QName

src/full/Agda/Syntax/Concrete/Operators.hs view

@@ -39,10 +39,12 @@ import Agda.TypeChecking.Monad.Base (typeError, TypeError(..)) import Agda.TypeChecking.Monad.State (getScope) import Agda.TypeChecking.Monad.Options+import Agda.TypeChecking.Monad.Statistics  import Agda.Utils.ReadP import Agda.Utils.Monad import Agda.Utils.Tuple+import Agda.Utils.List  import Debug.Trace @@ -80,7 +82,7 @@ localNames = do   defs   <- getDefinedNames [DefName, ConName]   locals <- scopeLocals <$> getScope-  return $ split $ nubBy ((==) `on` fst) $ map localOp locals ++ defs+  return $ split $ uniqBy fst $ map localOp locals ++ defs   where     localOp (x, y) = (x, A.nameFixity y)     split ops = ([ x | Left x <- zs], [ y | Right y <- zs ])@@ -224,35 +226,48 @@         App _ e1 e2     -> AppV e1 e2         OpApp r d es    -> OpAppV d es         HiddenArg _ e   -> HiddenArgV e+        InstanceArg _ e -> InstanceArgV e         Paren _ e       -> ParenV e         Lam _ bs    e   -> LamV bs e+        Underscore{}    -> WildV e         _               -> OtherV e     unExprView e = case e of         LocalV x      -> Ident (QName x)         AppV e1 e2    -> App (fuseRange e1 e2) e1 e2         OpAppV d es   -> OpApp (fuseRange d es) d es         HiddenArgV e  -> HiddenArg (getRange e) e+        InstanceArgV e -> InstanceArg (getRange e) e         ParenV e      -> Paren (getRange e) e         LamV bs e     -> Lam (fuseRange bs e) bs e+        WildV e       -> e         OtherV e      -> e + instance IsExpr Pattern where     exprView e = case e of         IdentP (QName x) -> LocalV x         AppP e1 e2       -> AppV e1 e2-        OpAppP r d es    -> OpAppV d es+        OpAppP r d es    -> OpAppV d (map Ordinary es)         HiddenP _ e      -> HiddenArgV e+        InstanceP _ e    -> InstanceArgV e         ParenP _ e       -> ParenV e+        WildP{}          -> WildV e         _                -> OtherV e     unExprView e = case e of         LocalV x         -> IdentP (QName x)         AppV e1 e2       -> AppP e1 e2-        OpAppV d es      -> OpAppP (fuseRange d es) d es+        OpAppV d es      -> let ess :: [Pattern]+                                ess = (map (fromOrdinary __IMPOSSIBLE__) es)+                            in OpAppP (fuseRange d es) d ess         HiddenArgV e     -> HiddenP (getRange e) e+        InstanceArgV e   -> InstanceP (getRange e) e         ParenV e         -> ParenP (getRange e) e         LamV _ _         -> __IMPOSSIBLE__+        WildV e          -> e         OtherV e         -> e ++ --------------------------------------------------------------------------- -- * Parse functions ---------------------------------------------------------------------------@@ -264,6 +279,7 @@     RawAppP _ ps     -> fullParen' <$> (parsePattern prs =<< parse prs ps)     OpAppP r d ps    -> fullParen' . OpAppP r d <$> mapM (parsePattern prs) ps     HiddenP _ _      -> fail "bad hidden argument"+    InstanceP _ _    -> fail "bad instance argument"     AsP r x p        -> AsP r x <$> parsePattern prs p     DotP r e         -> return $ DotP r e     ParenP r p       -> fullParen' <$> parsePattern prs p@@ -309,6 +325,7 @@             ParenP _ p       -> appView p             RawAppP _ _      -> __IMPOSSIBLE__             HiddenP _ _      -> __IMPOSSIBLE__+            InstanceP _ _    -> __IMPOSSIBLE__             _                -> [p]  parseApplication :: [Expr] -> ScopeM Expr@@ -340,15 +357,18 @@ fullParen' :: IsExpr e => e -> e fullParen' e = case exprView e of     LocalV _     -> e+    WildV _      -> e     OtherV _     -> e     HiddenArgV _ -> e+    InstanceArgV _ -> e     ParenV _     -> e     AppV e1 (Arg h r e2) -> par $ unExprView $ AppV (fullParen' e1) (Arg h r e2')         where             e2' = case h of                 Hidden    -> e2+                Instance  -> e2                 NotHidden -> fullParen' <$> e2-    OpAppV x es -> par $ unExprView $ OpAppV x $ map fullParen' es+    OpAppV x es -> par $ unExprView $ OpAppV x $ map (fmap fullParen') es     LamV bs e -> par $ unExprView $ LamV bs (fullParen e)     where         par = unExprView . ParenV@@ -358,10 +378,12 @@ paren f   e@(OpApp _ op _)     = do fx <- f op; return $ \p -> mparen (opBrackets fx p) e paren _   e@(Lam _ _ _)        = return $ \p -> mparen (lamBrackets p) e paren _   e@(AbsurdLam _ _)    = return $ \p -> mparen (lamBrackets p) e+paren _   e@(ExtendedLam _ _)    = return $ \p -> mparen (lamBrackets p) e paren _   e@(Fun _ _ _)        = return $ \p -> mparen (lamBrackets p) e paren _   e@(Pi _ _)           = return $ \p -> mparen (lamBrackets p) e paren _   e@(Let _ _ _)        = return $ \p -> mparen (lamBrackets p) e paren _   e@(Rec _ _)          = return $ \p -> mparen (appBrackets p) e+paren _   e@(RecUpdate _ _ _)  = return $ \p -> mparen (appBrackets p) e paren _   e@(WithApp _ _ _)    = return $ \p -> mparen (withAppBrackets p) e paren _   e@(Ident _)          = return $ \p -> e paren _   e@(Lit _)            = return $ \p -> e@@ -377,9 +399,12 @@ paren _   e@(ETel _)           = return $ \p -> e paren _   e@(RawApp _ _)       = __IMPOSSIBLE__ paren _   e@(HiddenArg _ _)    = __IMPOSSIBLE__+paren _   e@(InstanceArg _ _)  = __IMPOSSIBLE__ paren _   e@(QuoteGoal _ _ _)  = return $ \p -> mparen (lamBrackets p) e paren _   e@(Quote _)          = return $ \p -> e-+paren _   e@(QuoteTerm _)      = return $ \p -> e+paren _   e@(Unquote _)        = return $ \p -> e+paren _   e@(DontCare _)       = return $ \p -> e  mparen :: Bool -> Expr -> Expr mparen True  e = Paren (getRange e) e

src/full/Agda/Syntax/Concrete/Operators/Parser.hs view

@@ -16,10 +16,12 @@  data ExprView e     = LocalV Name+    | WildV e     | OtherV e     | AppV e (NamedArg e)-    | OpAppV Name [e]+    | OpAppV Name [OpApp e]     | HiddenArgV (Named String e)+    | InstanceArgV (Named String e)     | LamV [LamBinding] e     | ParenV e --    deriving (Show)@@ -112,23 +114,26 @@ -- | Given a name with a syntax spec, and a list of parsed expressions -- fitting it, rebuild the expression. -- Note that this function must not parse any input (as guaranteed by the type)-rebuild :: forall a e. IsExpr e => NewNotation -> Range -> [e] -> ReadP a e+rebuild :: forall symbol e. IsExpr e => NewNotation -> Range -> [e] -> ReadP symbol e rebuild (name,_,syn) r es = do   exprs <- mapM findExprFor [0..lastHole]   return $ unExprView $ OpAppV (setRange r name) exprs   where filledHoles = zip es (filter isAHole syn)         lastHole = maximum [t | Just t <- map holeTarget syn]-        findExprFor :: Int -> ReadP a e-        findExprFor n = case  [ e | (e,NormalHole m) <- filledHoles, m == n] of+        findExprFor :: Int -> ReadP a (OpApp e)+        findExprFor n = case [e | (e,NormalHole m) <- filledHoles, m == n] of                           [] -> fail $ "no expression for hole " ++ show n-                          [x] -> case [ e | (e,BindHole m) <- filledHoles, m == n] of-                                   [] -> return x -- no variable to bind+                          [x] -> case [e | (e,BindHole m) <- filledHoles, m == n] of+                                   [] -> return (Ordinary x) -- no variable to bind                                    vars -> do bs <- mapM rebuildBinding $ map exprView vars-                                              return $ unExprView $ LamV bs x+                                              return $ SyntaxBindingLambda (fuseRange bs x) bs x                           _ -> fail $ "more than one expression for hole " ++ show n  rebuildBinding :: ExprView e -> ReadP a LamBinding-rebuildBinding (LocalV name) = return $ DomainFree NotHidden (mkBoundName_ name)+  -- Andreas, 2011-04-07 put just 'Relevant' here, is this correct?+rebuildBinding (LocalV name) = return $ DomainFree NotHidden Relevant (mkBoundName_ name)+rebuildBinding (WildV e)     =+  return $ DomainFree NotHidden Relevant (mkBoundName_ $ Name noRange [Hole]) rebuildBinding _ = fail "variable name expected"  ($$$) :: (e -> ReadP a e) -> ReadP a e -> ReadP a e@@ -169,20 +174,28 @@ appP :: IsExpr e => ReadP e e -> ReadP e e -> ReadP e e appP top p = do     h  <- p-    es <- many (nothidden +++ hidden)+    es <- many (nothidden +++ hidden +++ instanceH)     return $ foldl app h es     where  	app e arg = unExprView $ AppV e arg  	isHidden (HiddenArgV _) = True-	isHidden _	       = False+	isHidden _	        = False +	isInstance (InstanceArgV _) = True+	isInstance _	            = False+ 	nothidden = Arg NotHidden Relevant . unnamed <$> do 	    e <- p 	    case exprView e of 		HiddenArgV _ -> pfail+		InstanceArgV _ -> pfail 		_	     -> return e++	instanceH = do+	    InstanceArgV e <- exprView <$> satisfy (isInstance . exprView)+	    return $ Arg Instance Relevant e  	hidden = do 	    HiddenArgV e <- exprView <$> satisfy (isHidden . exprView)

src/full/Agda/Syntax/Concrete/Pretty.hs view

@@ -32,12 +32,17 @@   '-':_ -> braces (text " " <> d)   _     -> braces d +-- double braces...+dbraces :: Doc -> Doc+dbraces = braces . braces'+ arrow  = text "\x2192" lambda = text "\x03bb" underscore = text "_"  pHidden :: Pretty a => Hiding -> a -> Doc pHidden Hidden	    = braces' . pretty+pHidden Instance    = dbraces . pretty pHidden NotHidden   = pretty  pRelevance :: Pretty a => Relevance -> a -> Doc@@ -46,6 +51,9 @@ pRelevance Irrelevant a =   let d = pretty a   in  if render d == "_" then d else text "." <> d+pRelevance NonStrict a =+  let d = pretty a+  in  if render d == "_" then d else text ".." <> d  {- UNUSED -- | Use for printing non-dependent function types@@ -53,6 +61,9 @@ prettyWithRelevance a = pRelevance (argRelevance a) a -} +instance Pretty (ThingWithFixity Name) where+    pretty (ThingWithFixity n _) = pretty n+ instance Pretty Name where     pretty = text . show @@ -60,7 +71,6 @@     pretty = text . show  instance Pretty Literal where-    pretty (LitLevel _ n)   = __IMPOSSIBLE__     pretty (LitInt _ n)	    = text $ show n     pretty (LitFloat _ x)   = text $ show x     pretty (LitString _ s)  = text $ showString' s ""@@ -83,11 +93,16 @@   pretty Forced     = empty   pretty Relevant   = empty   pretty Irrelevant = text "."+  pretty NonStrict  = text ".."  instance Pretty Induction where   pretty Inductive = text "data"   pretty CoInductive = text "codata" +instance Pretty (OpApp Expr) where+  pretty (Ordinary e) = pretty e+  pretty (SyntaxBindingLambda r bs e) = pretty (Lam r bs e)+ instance Pretty Expr where     pretty e = 	case e of@@ -115,12 +130,21 @@ 	      pretty e : map ((text "|" <+>) . pretty) es  	    HiddenArg _ e -> braces' $ pretty e+	    InstanceArg _ e -> dbraces $ pretty e 	    Lam _ bs e -> 		sep [ lambda <+> fsep (map pretty bs) <+> arrow 		    , nest 2 $ pretty e 		    ]             AbsurdLam _ NotHidden -> lambda <+> text "()"+            AbsurdLam _ Instance -> lambda <+> text "{{}}"             AbsurdLam _ Hidden -> lambda <+> text "{}"+	    ExtendedLam _ pes ->+		lambda <+> braces (fsep $ punctuate (text ";") (map (\(x,y,z) -> prettyClause x y z) pes))+                   where prettyClause lhs rhs wh = sep [ pretty lhs+                                                       , nest 2 $ pretty' rhs+                                                       ] $$ nest 2 (pretty wh)+                         pretty' (RHS e)   = arrow <+> pretty e+                         pretty' AbsurdRHS = empty 	    Fun _ e1 e2 -> 		sep [ pretty e1 <+> arrow 		    , pretty e2@@ -141,33 +165,41 @@ 	    Dot _ e   -> text "." <> pretty e 	    Absurd _  -> text "()" 	    Rec _ xs  -> sep (-	      [ text "record {" ] ++-	      punctuate (text ";") (map pr xs)) <+> text "}"-	      where-		pr (x, e) = sep [ pretty x <+> text "="-				, nest 2 $ pretty e-				]+	        [ text "record {" ] +++	        punctuate (text ";") (map recPr xs)) <+> text "}"+	    RecUpdate _ e xs ->+	            sep [ text "record" <+> pretty e <+> text "{" ]+	        <+> sep (punctuate (text ";") (map recPr xs))+	        <+> text "}"             ETel []  -> text "()"             ETel tel -> fsep $ map pretty tel             QuoteGoal _ x e -> sep [text "quoteGoal" <+> pretty x <+> text "in",                                     nest 2 $ pretty e]             Quote _ -> text "quote"+            QuoteTerm _ -> text "quoteTerm"+	    Unquote _ -> text "unquote"+            -- Andreas, 2011-10-03 print irrelevant things as .(e)+            DontCare e -> text "." <> parens (pretty e)+	where+	  recPr (x, e) = sep [ pretty x <+> text "=" , nest 2 $ pretty e ]  instance Pretty BoundName where   pretty = pretty . boundName  instance Pretty LamBinding where-    pretty (DomainFree h x) = pHidden h (pretty x)-    pretty (DomainFull b)   = pretty b+    pretty (DomainFree h r x) = pRelevance r $ pHidden h $ pretty x+    pretty (DomainFull b)     = pretty b  instance Pretty TypedBindings where-    pretty (TypedBindings _ (Arg h rel bs)) =-	pRelevance rel $ bracks $ fsep $ punctuate semi $ map pretty bs+    pretty (TypedBindings _ (Arg h rel b)) =+	pRelevance rel $ bracks $ pretty b 	where 	    bracks = case h of 			Hidden	    -> braces'+			Instance    -> dbraces 			NotHidden   -> parens + instance Pretty TypedBinding where     pretty (TNoBind e) = pretty e     pretty (TBind _ xs e) =@@ -176,17 +208,19 @@ 	    ]  smashTel :: Telescope -> Telescope-smashTel (TypedBindings r (Arg h  rel  [TBind r' xs e]) :-          TypedBindings _ (Arg h' rel' [TBind _  ys e']) : tel)+smashTel (TypedBindings r (Arg h  rel  (TBind r' xs e)) :+          TypedBindings _ (Arg h' rel' (TBind _  ys e')) : tel)   | h == h' && rel == rel' && show e == show e' =-    smashTel (TypedBindings r (Arg h rel [TBind r' (xs ++ ys) e]) : tel)+    smashTel (TypedBindings r (Arg h rel (TBind r' (xs ++ ys) e)) : tel) smashTel (b : tel) = b : smashTel tel smashTel [] = [] + instance Pretty RHS where     pretty (RHS e)   = text "=" <+> pretty e     pretty AbsurdRHS = empty +instance Show WhereClause where show = show . pretty instance Pretty WhereClause where   pretty  NoWhere = empty   pretty (AnyWhere [Module _ x [] ds]) | isNoName (unqualify x)@@ -197,6 +231,7 @@ 	 , nest 2 (vcat $ map pretty ds) 	 ] +instance Show LHS where show = show . pretty instance Pretty LHS where   pretty lhs = case lhs of     LHS p ps eqs es  -> pr (pretty p) ps eqs es@@ -215,6 +250,11 @@ instance Pretty [Declaration] where   pretty = vcat . map pretty +instance Show ModuleApplication where show = show . pretty+instance Pretty ModuleApplication where+  pretty (SectionApp _ bs e) = fsep (map pretty bs) <+> text "=" <+> pretty e+  pretty (RecordModuleIFS _ rec) = text "=" <+> pretty rec <+> text "{{...}}"+ instance Pretty Declaration where     pretty d = 	case d of@@ -230,7 +270,7 @@ 		sep [ pretty lhs 		    , nest 2 $ pretty rhs 		    ] $$ nest 2 (pretty wh)-	    Data _ ind x tel e cs ->+	    DataSig _ ind x tel e -> 		sep [ hsep  [ pretty ind 			    , pretty x 			    , fcat (map pretty tel)@@ -238,10 +278,27 @@ 		    , nest 2 $ hsep 			    [ text ":" 			    , pretty e+			    ]+		    ]+	    Data _ ind x tel (Just e) cs ->+		sep [ hsep  [ pretty ind+			    , pretty x+			    , fcat (map pretty tel)+			    ]+		    , nest 2 $ hsep+			    [ text ":"+			    , pretty e 			    , text "where" 			    ] 		    ] $$ nest 2 (vcat $ map pretty cs)-	    Record _ x con tel e cs ->+	    Data _ ind x tel Nothing cs ->+		sep [ hsep  [ pretty ind+			    , pretty x+			    , fcat (map pretty tel)+			    ]+		    , nest 2 $ text "where"+		    ] $$ nest 2 (vcat $ map pretty cs)+	    RecordSig _ x tel e -> 		sep [ hsep  [ text "record" 			    , pretty x 			    , fcat (map pretty tel)@@ -249,12 +306,32 @@ 		    , nest 2 $ hsep 			    [ text ":" 			    , pretty e+			    ]+		    ]+	    Record _ x con tel (Just e) cs ->+		sep [ hsep  [ text "record"+			    , pretty x+			    , fcat (map pretty tel)+			    ]+		    , nest 2 $ hsep+			    [ text ":"+			    , pretty e 			    , text "where" 			    ] 		    ] $$ nest 2 (vcat $ maybe [] (\c -> [text "constructor" <+> pretty c])                                               con ++                                         map pretty cs)-	    Infix f xs	->+	    Record _ x con tel Nothing cs ->+		sep [ hsep  [ text "record"+			    , pretty x+			    , fcat (map pretty tel)+			    ]+		    , nest 2 $ text "where"+		    ] $$ nest 2 (vcat $ maybe [] (\c -> [text "constructor" <+> pretty c])+                                              con +++                                        map pretty cs)++            Infix f xs	-> 		pretty f <+> (fsep $ punctuate comma $ map pretty xs)             Syntax n xs -> text "syntax" <+> pretty n <+> text "..." 	    Mutual _ ds	    -> namedBlock "mutual" ds@@ -268,15 +345,19 @@ 		     , fcat (map pretty tel) 		     , text "where" 		     ] $$ nest 2 (vcat $ map pretty ds)-	    ModuleMacro _ x [] e DoOpen i | isNoName x ->+	    ModuleMacro _ x (SectionApp _ [] e) DoOpen i | isNoName x -> 		sep [ pretty DoOpen                     , nest 2 $ pretty e                     , nest 4 $ pretty i                     ]-	    ModuleMacro _ x tel e open i ->+	    ModuleMacro _ x (SectionApp _ tel e) open i -> 		sep [ pretty open <+> text "module" <+> pretty x <+> fcat (map pretty tel) 		    , nest 2 $ text "=" <+> pretty e <+> pretty i 		    ]+	    ModuleMacro _ x (RecordModuleIFS _ rec) open i ->+		sep [ pretty open <+> text "module" <+> pretty x+		    , nest 2 $ text "=" <+> pretty rec <+> text "{{...}}"+		    ] 	    Open _ x i	-> hsep [ text "open", pretty x, pretty i ] 	    Import _ x rn open i   -> 		hsep [ pretty open, text "import", pretty x, as rn, pretty i ]@@ -305,6 +386,10 @@       hsep $ [text "COMPILED_DATA", pretty x] ++ map text (hs : hcs)     pretty (CompiledEpicPragma _ x e) =       hsep [ text "COMPILED_EPIC", pretty x, text e ]+    pretty (CompiledJSPragma _ x e) =+      hsep [ text "COMPILED_JS", pretty x, text e ]+    pretty (StaticPragma _ i) =+      hsep $ [text "STATIC", pretty i]     pretty (ImportPragma _ i) =       hsep $ [text "IMPORT", text i]     pretty (ImpossiblePragma _) =@@ -342,9 +427,10 @@ 		    prOp (Hole : _)  []	      = __IMPOSSIBLE__ 		    prOp (Id x : xs) es       = text x : prOp xs es 		    prOp []	     []       = []-		    prOp []	     (_ : _)  = __IMPOSSIBLE__+		    prOp []	     es       = map pretty es 	    OpAppP _ (NoName _ _) _ -> __IMPOSSIBLE__ 	    HiddenP _ p	       -> braces' $ pretty p+	    InstanceP _ p      -> dbraces $ pretty p 	    ParenP _ p	       -> parens $ pretty p 	    WildP _	       -> underscore 	    AsP _ x p	       -> pretty x <> text "@" <> pretty p

src/full/Agda/Syntax/Fixity.hs view

@@ -1,10 +1,12 @@-{-# LANGUAGE CPP, DeriveDataTypeable #-}+{-# LANGUAGE CPP, DeriveDataTypeable, DeriveFunctor, DeriveFoldable, DeriveTraversable #-}  {-| Definitions for fixity and precedence levels. -} module Agda.Syntax.Fixity where  import Data.Generics (Typeable, Data)+import Data.Foldable+import Data.Traversable  import Agda.Syntax.Position import Agda.Syntax.Common@@ -18,6 +20,7 @@      theNotation :: Notation}   deriving (Typeable, Data, Show, Eq) +data ThingWithFixity x = ThingWithFixity x Fixity' deriving (Functor,Foldable,Traversable,Typeable,Data,Show) -- | All the notation information related to a name. type NewNotation = (Name, Fixity, Notation) @@ -73,6 +76,7 @@ hiddenArgumentCtx :: Hiding -> Precedence hiddenArgumentCtx NotHidden = ArgumentCtx hiddenArgumentCtx Hidden    = TopCtx+hiddenArgumentCtx Instance  = TopCtx  -- | Do we need to bracket an operator application of the given fixity --   in a context with the given precedence.@@ -92,14 +96,18 @@ opBrackets _ WithFunCtx             = False opBrackets _ _			    = True --- | Does a lambda-like thing (lambda, let or pi) need brackets in the given---   context. A peculiar thing with lambdas is that they don't need brackets---   in a right operand context. For instance: @m >>= \x -> m'@ is a valid---   infix application.+-- | Does a lambda-like thing (lambda, let or pi) need brackets in the+-- given context? A peculiar thing with lambdas is that they don't+-- need brackets in certain right operand contexts. However, we insert+-- brackets anyway, for the following reasons:+--+-- * Clarity.+--+-- * Sometimes brackets are needed. Example: @m₁ >>= (λ x → x) >>= m₂@+--   (here @_>>=_@ is left associative). lamBrackets :: Precedence -> Bool-lamBrackets TopCtx		= False-lamBrackets (RightOperandCtx _) = False-lamBrackets _			= True+lamBrackets TopCtx = False+lamBrackets _	   = True  -- | Does a function application need brackets? appBrackets :: Precedence -> Bool

src/full/Agda/Syntax/Internal.hs view

@@ -1,4 +1,5 @@-{-# LANGUAGE CPP, DeriveDataTypeable, GeneralizedNewtypeDeriving #-}+{-# LANGUAGE CPP, DeriveDataTypeable, GeneralizedNewtypeDeriving,+             DeriveFunctor, DeriveFoldable, DeriveTraversable #-}  module Agda.Syntax.Internal     ( module Agda.Syntax.Internal@@ -11,6 +12,7 @@ import Data.Foldable import Data.Traversable import Data.Function+import qualified Data.List as List  import Agda.Syntax.Position import Agda.Syntax.Common@@ -37,50 +39,54 @@ 	  | Def QName Args 	  | Con QName Args 	  | Pi (Arg Type) (Abs Type)-	  | Fun (Arg Type) Type 	  | Sort Sort+          | Level Level 	  | MetaV MetaId Args-          | DontCare               -- ^ nuked irrelevant and other stuff-  deriving (Typeable, Data, Eq, Ord, Show)--- Andreas 2010-09-21: @DontCare@ replaces the hack @Sort Prop@+          | DontCare Term  -- ^ irrelevant stuff+  deriving (Typeable, Data, Show)  data Type = El Sort Term-  deriving (Typeable, Data, Eq, Ord, Show)+  deriving (Typeable, Data, Show) -data Sort = Type Term   -- A term of type Level+data Elim = Apply (Arg Term) | Proj QName -- ^ name of a record projection+  deriving (Show)++-- | Top sort (Set\omega).+topSort :: Type+topSort = El Inf (Sort Inf)++data Sort = Type Level 	  | Prop  -- ignore me-	  | Lub Sort Sort-	  | Suc Sort-	  | MetaS MetaId Args           | Inf           | DLub Sort (Abs Sort)             -- ^ if the free variable occurs in the second sort             --   the whole thing should reduce to Inf, otherwise             --   it's the normal Lub-  deriving (Typeable, Data, Eq, Ord, Show)+  deriving (Typeable, Data, Show) +newtype Level = Max [PlusLevel]+  deriving (Show, Typeable, Data)++data PlusLevel = ClosedLevel Integer+               | Plus Integer LevelAtom+  deriving (Show, Typeable, Data)++data LevelAtom = MetaLevel MetaId Args+               | BlockedLevel MetaId Term+               | NeutralLevel Term+               | UnreducedLevel Term+  deriving (Show, Typeable, Data)+ -- | Something where a meta variable may block reduction. data Blocked t = Blocked MetaId t                | NotBlocked t-    deriving (Typeable, Data, Eq, Ord)+    deriving (Typeable, Data, Eq, Ord, Functor, Foldable, Traversable)  instance Show t => Show (Blocked t) where   showsPrec p (Blocked m x) = showParen (p > 0) $     showString "Blocked " . shows m . showString " " . showsPrec 10 x   showsPrec p (NotBlocked x) = showsPrec p x -instance Functor Blocked where-  fmap f (Blocked m t) = Blocked m $ f t-  fmap f (NotBlocked t) = NotBlocked $ f t--instance Foldable Blocked where-  foldr f z (Blocked _ x) = f x z-  foldr f z (NotBlocked x) = f x z--instance Traversable Blocked where-  traverse f (Blocked m t)  = Blocked m <$> f t-  traverse f (NotBlocked t) = NotBlocked <$> f t- instance Applicative Blocked where   pure = notBlocked   Blocked x f  <*> e = Blocked x $ f (ignoreBlocking e)@@ -88,33 +94,59 @@  instance Sized Term where   size v = case v of-    Var _ vs   -> 1 + Prelude.sum (map size vs)-    Def _ vs   -> 1 + Prelude.sum (map size vs)-    Con _ vs   -> 1 + Prelude.sum (map size vs)-    MetaV _ vs -> 1 + Prelude.sum (map size vs)-    Lam _ f    -> 1 + size f-    Lit _      -> 1-    Pi a b     -> 1 + size a + size b-    Fun a b    -> 1 + size a + size b-    Sort s     -> 1-    DontCare   -> 1+    Var _ vs    -> 1 + Prelude.sum (map size vs)+    Def _ vs    -> 1 + Prelude.sum (map size vs)+    Con _ vs    -> 1 + Prelude.sum (map size vs)+    MetaV _ vs  -> 1 + Prelude.sum (map size vs)+    Level l     -> size l+    Lam _ f     -> 1 + size f+    Lit _       -> 1+    Pi a b      -> 1 + size a + size b+    Sort s      -> 1+    DontCare mv -> size mv  instance Sized Type where   size = size . unEl +instance Sized Level where+  size (Max as) = 1 + Prelude.sum (map size as)++instance Sized PlusLevel where+  size (ClosedLevel _) = 1+  size (Plus _ a) = size a++instance Sized LevelAtom where+  size (MetaLevel _ vs) = 1 + Prelude.sum (map size vs)+  size (BlockedLevel _ v) = size v+  size (NeutralLevel v) = size v+  size (UnreducedLevel v) = size v+ instance KillRange Term where   killRange v = case v of-    Var i vs   -> killRange1 (Var i) vs-    Def c vs   -> killRange2 Def c vs-    Con c vs   -> killRange2 Con c vs-    MetaV m vs -> killRange1 (MetaV m) vs-    Lam h f    -> killRange2 Lam h f-    Lit l      -> killRange1 Lit l-    Pi a b     -> killRange2 Pi a b-    Fun a b    -> killRange2 Fun a b-    Sort s     -> killRange1 Sort s-    DontCare   -> DontCare+    Var i vs    -> killRange1 (Var i) vs+    Def c vs    -> killRange2 Def c vs+    Con c vs    -> killRange2 Con c vs+    MetaV m vs  -> killRange1 (MetaV m) vs+    Lam h f     -> killRange2 Lam h f+    Lit l       -> killRange1 Lit l+    Level l     -> killRange1 Level l+    Pi a b      -> killRange2 Pi a b+    Sort s      -> killRange1 Sort s+    DontCare mv -> killRange1 DontCare mv +instance KillRange Level where+  killRange (Max as) = killRange1 Max as++instance KillRange PlusLevel where+  killRange l@ClosedLevel{} = l+  killRange (Plus n l) = killRange1 (Plus n) l++instance KillRange LevelAtom where+  killRange (MetaLevel n as)   = killRange1 (MetaLevel n) as+  killRange (BlockedLevel m v) = killRange1 (BlockedLevel m) v+  killRange (NeutralLevel v)   = killRange1 NeutralLevel v+  killRange (UnreducedLevel v) = killRange1 UnreducedLevel v+ instance KillRange Type where   killRange (El s v) = killRange2 El s v @@ -123,10 +155,7 @@     Prop       -> Prop     Inf        -> Inf     Type a     -> killRange1 Type a-    Suc s      -> killRange1 Suc s-    Lub s1 s2  -> killRange2 Lub s1 s2     DLub s1 s2 -> killRange2 DLub s1 s2-    MetaS x as -> killRange1 (MetaS x) as  instance KillRange a => KillRange (Tele a) where   killRange = fmap killRange@@ -150,82 +179,43 @@ -- | Sequence of types. An argument of the first type is bound in later types --   and so on. data Tele a = EmptyTel-	    | ExtendTel a (Abs (Tele a))-  deriving (Typeable, Data, Show, Eq, Ord)+	    | ExtendTel a (Abs (Tele a))  -- ^ Abs is never NoAbs.+  deriving (Typeable, Data, Show, Functor, Foldable, Traversable)  type Telescope = Tele (Arg Type) -instance Functor Tele where-  fmap f  EmptyTel         = EmptyTel-  fmap f (ExtendTel a tel) = ExtendTel (f a) (fmap (fmap f) tel)- instance Sized (Tele a) where   size  EmptyTel	 = 0   size (ExtendTel _ tel) = 1 + size tel  -- | The body has (at least) one free variable.-data Abs a = Abs { absName :: String-		 , absBody :: a-		 }-  deriving (Typeable, Data)+data Abs a = Abs String a+           | NoAbs String a+  deriving (Typeable, Data, Functor, Foldable, Traversable) -instance Eq a => Eq (Abs a) where-  (==) = (==) `on` absBody+-- | Danger: doesn't shift variables properly+unAbs :: Abs a -> a+unAbs (Abs   _ v) = v+unAbs (NoAbs _ v) = v -instance Ord a => Ord (Abs a) where-  compare = compare `on` absBody+absName :: Abs a -> String+absName (Abs   x _) = x+absName (NoAbs x _) = x  instance Show a => Show (Abs a) where   showsPrec p (Abs x a) = showParen (p > 0) $     showString "Abs " . shows x . showString " " . showsPrec 10 a--instance Functor Abs where-  fmap f (Abs x t) = Abs x $ f t--instance Foldable Abs where-  foldr f z (Abs _ t) = f t z--instance Traversable Abs where-  traverse f (Abs x t) = Abs x <$> f t+  showsPrec p (NoAbs x a) = showParen (p > 0) $+    showString "NoAbs " . shows x . showString " " . showsPrec 10 a  instance Sized a => Sized (Abs a) where-  size = size . absBody--telFromList :: [Arg (String, Type)] -> Telescope-telFromList = foldr (\(Arg h r (x, a)) -> ExtendTel (Arg h r a) . Abs x) EmptyTel--telToList :: Telescope -> [Arg (String, Type)]-telToList EmptyTel = []-telToList (ExtendTel arg (Abs x tel)) = fmap ((,) x) arg : telToList tel+  size = size . unAbs  -- -- Definitions -- --- | Pairs consisting of original and translated clauses.-data Clauses = Clauses-  { maybeOriginalClause :: Maybe Clause-    -- ^ The original clause, before translation of record patterns.-    -- 'Nothing' if the translated clause is identical to the original-    -- one.-  , translatedClause :: Clause-    -- ^ The translated clause.-  }-  deriving (Typeable, Data, Show)---- | The original clause, before translation of record patterns.-originalClause :: Clauses -> Clause-originalClause Clauses{ maybeOriginalClause = Just c } = c-originalClause Clauses{ maybeOriginalClause = Nothing-                      , translatedClause    = c      } = c--instance HasRange Clauses where-  getRange = getRange . translatedClause---- | A clause is a list of patterns and the clause body should @Bind@ or--- @NoBind@ in the order the variables occur in the patterns. The @NoBind@--- constructor is an optimisation to avoid substituting for variables that--- aren't used. (Note: This optimisation has been disabled.)+-- | A clause is a list of patterns and the clause body should @Bind@. -- --  The telescope contains the types of the pattern variables and the --  permutation is how to get from the order the variables occur in@@ -244,9 +234,7 @@   deriving (Typeable, Data, Show) data ClauseBody = Body Term 		| Bind (Abs ClauseBody)-		| NoBind ClauseBody-		| NoBody    -- ^ for absurd clauses.  A @NoBody@ is never-                            -- preceded by any @Bind@ or @NoBind@.+		| NoBody    -- ^ for absurd clauses.   deriving (Typeable, Data, Show)  instance HasRange Clause where@@ -276,35 +264,19 @@  -- | Doesn't do any reduction. arity :: Type -> Nat-arity t =-    case unEl t of-	Pi  _ (Abs _ b) -> 1 + arity b-	Fun _	     b	-> 1 + arity b-	_		-> 0+arity t = case unEl t of+  Pi  _ b -> 1 + arity (unAbs b)+  _       -> 0  -- | Suggest a name for the first argument of a function of the given type. argName :: Type -> String argName = argN . unEl     where 	argN (Pi _ b)  = "." ++ absName b-	argN (Fun _ _) = ".x" 	argN _	  = __IMPOSSIBLE__   ------------------------------------------------------------------------------ * Views------------------------------------------------------------------------------data FunView-	= FunV (Arg Type) Term	-- ^ second arg is the entire type ('Pi' or 'Fun').-	| NoFunV Term--funView :: Term -> FunView-funView t@(Pi  arg _) = FunV arg t-funView t@(Fun arg _) = FunV arg t-funView t	      = NoFunV t----------------------------------------------------------------------------- -- * Smart constructors --------------------------------------------------------------------------- @@ -322,47 +294,31 @@ ignoreBlocking (Blocked _ x) = x ignoreBlocking (NotBlocked x) = x -set0   = set 0-set n  = sort $ mkType n-prop   = sort Prop-sort s = El (sSuc s) $ Sort s+set0      = set 0+set n     = sort $ mkType n+prop      = sort Prop+sort s    = El (sSuc s) $ Sort s+varSort n = Type $ Max [Plus 0 $ NeutralLevel $ Var n []] -mkType n = Type $ Lit $ LitLevel noRange n+-- | Get the next higher sort.+sSuc :: Sort -> Sort+sSuc Prop            = mkType 1+sSuc Inf             = Inf+sSuc (DLub a b)      = DLub (sSuc a) (fmap sSuc b)+sSuc (Type l)        = Type $ levelSuc l -teleLam :: Telescope -> Term -> Term-teleLam  EmptyTel	  t = t-teleLam (ExtendTel u tel) t = Lam (argHiding u) $ flip teleLam t <$> tel+levelSuc (Max []) = Max [ClosedLevel 1]+levelSuc (Max as) = Max $ map inc as+  where inc (ClosedLevel n) = ClosedLevel (n + 1)+        inc (Plus n l)      = Plus (n + 1) l +mkType n = Type $ Max [ClosedLevel n | n > 0]+ getSort :: Type -> Sort getSort (El s _) = s  unEl :: Type -> Term unEl (El _ t) = t---- | Get the next higher sort.-sSuc :: Sort -> Sort-sSuc Prop                      = mkType 1-sSuc (Type (Lit (LitLevel _ n))) = mkType (n + 1)-sSuc Inf                       = Inf-sSuc s                         = Suc s--sLub :: Sort -> Sort -> Sort-sLub (Type (Lit (LitLevel _ 0))) Prop                      = Prop   -- (x:A) -> B prop if A type0, B prop [x:A]-sLub (Type (Lit (LitLevel _ n))) Prop                      = mkType n-sLub Prop (Type (Lit (LitLevel _ n)))                      = mkType n-sLub (Type (Lit (LitLevel _ n))) (Type (Lit (LitLevel _ m))) = mkType $ max n m-sLub (Suc a) (Suc b) = Suc (sLub a b)-sLub (Type (Lit (LitLevel _ n))) (Suc a)-  | n > 0     = sSuc (mkType (n - 1) `sLub` a)-  | otherwise = Suc a-sLub (Suc a) (Type (Lit (LitLevel _ n)))-  | n > 0     = sSuc (a `sLub` mkType (n - 1))-  | otherwise = Suc a-sLub Inf _ = Inf-sLub _ Inf = Inf-sLub s1 s2-    | s1 == s2	= s1-    | otherwise	= Lub s1 s2  impossibleTerm :: String -> Int -> Term impossibleTerm file line = Lit $ LitString noRange $ unlines

src/full/Agda/Syntax/Internal/Generic.hs view

@@ -27,6 +27,11 @@   traverseTermM f = traverse (traverseTermM f)   foldTerm f = foldMap (foldTerm f) +instance TermLike a => TermLike (Maybe a) where+  traverseTerm f = fmap (traverseTerm f)+  traverseTermM f = traverse (traverseTermM f)+  foldTerm f = foldMap (foldTerm f)+ instance (TermLike a, TermLike b) => TermLike (a, b) where   traverseTerm f (x, y) = (traverseTerm f x, traverseTerm f y)   traverseTermM f (x, y) = (,) <$> traverseTermM f x <*> traverseTermM f y@@ -39,40 +44,72 @@  instance TermLike Term where   traverseTerm f t = case t of-    Var i xs -> f $ Var i $ traverseTerm f xs-    Def c xs -> f $ Def c $ traverseTerm f xs-    Con c xs -> f $ Con c $ traverseTerm f xs-    Lam h b  -> f $ Lam h $ traverseTerm f b-    Pi a b   -> f $ uncurry Pi $ traverseTerm f (a, b)-    Fun a b  -> f $ uncurry Fun $ traverseTerm f (a, b)-    MetaV m xs -> f $ MetaV m $ traverseTerm f xs-    Lit _    -> f t-    Sort _   -> f t-    DontCare -> f t+    Var i xs    -> f $ Var i $ traverseTerm f xs+    Def c xs    -> f $ Def c $ traverseTerm f xs+    Con c xs    -> f $ Con c $ traverseTerm f xs+    Lam h b     -> f $ Lam h $ traverseTerm f b+    Pi a b      -> f $ uncurry Pi $ traverseTerm f (a, b)+    MetaV m xs  -> f $ MetaV m $ traverseTerm f xs+    Level l     -> f $ Level $ traverseTerm f l+    Lit _       -> f t+    Sort _      -> f t+    DontCare mv -> f $ DontCare $ traverseTerm f mv    traverseTermM f t = case t of-    Var i xs -> f =<< Var i <$> traverseTermM f xs-    Def c xs -> f =<< Def c <$> traverseTermM f xs-    Con c xs -> f =<< Con c <$> traverseTermM f xs-    Lam h b  -> f =<< Lam h <$> traverseTermM f b-    Pi a b   -> f =<< uncurry Pi <$> traverseTermM f (a, b)-    Fun a b  -> f =<< uncurry Fun <$> traverseTermM f (a, b)-    MetaV m xs -> f =<< MetaV m <$> traverseTermM f xs-    Lit _    -> f t-    Sort _   -> f t-    DontCare -> f t+    Var i xs    -> f =<< Var i <$> traverseTermM f xs+    Def c xs    -> f =<< Def c <$> traverseTermM f xs+    Con c xs    -> f =<< Con c <$> traverseTermM f xs+    Lam h b     -> f =<< Lam h <$> traverseTermM f b+    Pi a b      -> f =<< uncurry Pi <$> traverseTermM f (a, b)+    MetaV m xs  -> f =<< MetaV m <$> traverseTermM f xs+    Level l     -> f =<< Level <$> traverseTermM f l+    Lit _       -> f t+    Sort _      -> f t+    DontCare mv -> f =<< DontCare <$> traverseTermM f mv    foldTerm f t = f t `mappend` case t of-    Var i xs   -> foldTerm f xs-    Def c xs   -> foldTerm f xs-    Con c xs   -> foldTerm f xs-    Lam h b    -> foldTerm f b-    Pi a b     -> foldTerm f (a, b)-    Fun a b    -> foldTerm f (a, b)-    MetaV m xs -> foldTerm f xs-    Lit _      -> mempty-    Sort _     -> mempty-    DontCare   -> mempty+    Var i xs    -> foldTerm f xs+    Def c xs    -> foldTerm f xs+    Con c xs    -> foldTerm f xs+    Lam h b     -> foldTerm f b+    Pi a b      -> foldTerm f (a, b)+    MetaV m xs  -> foldTerm f xs+    Level l     -> foldTerm f l+    Lit _       -> mempty+    Sort _      -> mempty+    DontCare mv -> foldTerm f mv++instance TermLike Level where+  traverseTerm f  (Max as) = Max $ traverseTerm f as+  traverseTermM f (Max as) = Max <$> traverseTermM f as+  foldTerm f      (Max as) = foldTerm f as++instance TermLike PlusLevel where+  traverseTerm f l = case l of+    ClosedLevel{} -> l+    Plus n l      -> Plus n $ traverseTerm f l+  traverseTermM f l = case l of+    ClosedLevel{} -> return l+    Plus n l      -> Plus n <$> traverseTermM f l+  foldTerm f ClosedLevel{} = mempty+  foldTerm f (Plus _ l)    = foldTerm f l++instance TermLike LevelAtom where+  traverseTerm f l = case l of+    MetaLevel m vs   -> MetaLevel m $ traverseTerm f vs+    NeutralLevel v   -> NeutralLevel $ traverseTerm f v+    BlockedLevel m v -> BlockedLevel m $ traverseTerm f v+    UnreducedLevel v -> UnreducedLevel $ traverseTerm f v+  traverseTermM f l = case l of+    MetaLevel m vs   -> MetaLevel m <$> traverseTermM f vs+    NeutralLevel v   -> NeutralLevel <$> traverseTermM f v+    BlockedLevel m v -> BlockedLevel m <$> traverseTermM f v+    UnreducedLevel v -> UnreducedLevel <$> traverseTermM f v+  foldTerm f l = case l of+    MetaLevel m vs   -> foldTerm f vs+    NeutralLevel v   -> foldTerm f v+    BlockedLevel _ v -> foldTerm f v+    UnreducedLevel v -> foldTerm f v  instance TermLike Type where   traverseTerm f (El s t) = El s $ traverseTerm f t

src/full/Agda/Syntax/Literal.hs view

@@ -6,7 +6,6 @@ import Agda.Syntax.Abstract.Name  data Literal = LitInt    Range Integer-             | LitLevel  Range Integer 	     | LitFloat  Range Double 	     | LitString Range String 	     | LitChar   Range Char@@ -14,7 +13,6 @@   deriving (Typeable, Data, Show)  instance Eq Literal where-  LitLevel _ n  == LitLevel _ m  = n == m   LitInt _ n    == LitInt _ m    = n == m   LitFloat _ x  == LitFloat _ y  = x == y   LitString _ s == LitString _ t = s == t@@ -23,13 +21,10 @@   _             == _             = False  instance Ord Literal where-  LitLevel _ n  `compare` LitLevel _ m  = n `compare` m   LitInt _ n    `compare` LitInt _ m    = n `compare` m   LitFloat _ x  `compare` LitFloat _ y  = x `compare` y   LitString _ s `compare` LitString _ t = s `compare` t   LitChar _ c   `compare` LitChar _ d   = c `compare` d-  compare LitLevel{}    _ = LT-  compare _ LitLevel{} = GT   compare LitInt{}    _ = LT   compare _ LitInt{} = GT   compare LitFloat{}  _ = LT@@ -40,7 +35,6 @@   compare _ LitQName{}  = GT  instance HasRange Literal where-  getRange (LitLevel  r _) = r   getRange (LitInt    r _) = r   getRange (LitFloat  r _) = r   getRange (LitString r _) = r@@ -48,7 +42,6 @@   getRange (LitQName  r _) = r  instance SetRange Literal where-  setRange r (LitLevel  _ x) = LitLevel  r x   setRange r (LitInt    _ x) = LitInt    r x   setRange r (LitFloat  _ x) = LitFloat  r x   setRange r (LitString _ x) = LitString r x@@ -56,7 +49,6 @@   setRange r (LitQName  _ x) = LitQName  r x  instance KillRange Literal where-  killRange (LitLevel  r x) = LitLevel  (killRange r) x   killRange (LitInt    r x) = LitInt    (killRange r) x   killRange (LitFloat  r x) = LitFloat  (killRange r) x   killRange (LitString r x) = LitString (killRange r) x

src/full/Agda/Syntax/Notation.hs view

@@ -48,6 +48,10 @@              | IdPart String   deriving (Data, Typeable, Show, Eq) +-- | Get a flat list of identifier parts of a notation.+stringParts :: Notation -> [String]+stringParts gs = [ x | IdPart x <- gs ]+ -- | Target argument position of a part (Nothing if it is not a hole) holeTarget (BindHole n) = Just n holeTarget (NormalHole n) = Just n

src/full/Agda/Syntax/Parser/Alex.hs view

@@ -6,7 +6,7 @@     ( -- * Alex requirements       AlexInput(..)     , alexInputPrevChar-    , alexGetChar+    , alexGetChar, alexGetByte       -- * Lex actions     , LexAction, LexPredicate     , (.&&.), (.||.), not'@@ -16,7 +16,9 @@     )     where +import Control.Arrow import Control.Monad.State+import Data.Word  import Agda.Syntax.Position import Agda.Syntax.Parser.Monad@@ -36,6 +38,8 @@ alexInputPrevChar = lexPrevChar  -- | Lex a character. No surprises.+--+-- This function is used by Alex 2. alexGetChar :: AlexInput -> Maybe (Char, AlexInput) alexGetChar (AlexInput { lexInput = []  }) = Nothing alexGetChar (AlexInput { lexInput = c:s, lexPos = p }) =@@ -45,6 +49,15 @@ 		 , lexPrevChar	= c 		 } 	 )++-- | A variant of 'alexGetChar'.+--+-- This function is used by Alex 3.+alexGetByte :: AlexInput -> Maybe (Word8, AlexInput)+alexGetByte ai =+  -- Note that we ensure that every character presented to Alex fits+  -- in seven bits.+  (fromIntegral . fromEnum *** id) <$> alexGetChar ai  {--------------------------------------------------------------------------     Monad operations

src/full/Agda/Syntax/Parser/LexActions.hs view

@@ -75,6 +75,8 @@ postToken :: Token -> Token postToken (TokId (r, "\x03bb")) = TokSymbol SymLambda r postToken (TokId (r, "\x2192")) = TokSymbol SymArrow r+postToken (TokId (r, "\x2983")) = TokSymbol SymDoubleOpenBrace r+postToken (TokId (r, "\x2984")) = TokSymbol SymDoubleCloseBrace r postToken (TokId (r, "\x2200")) = TokKeyword KwForall r postToken (TokId (r, s))   | set == "Set" && all isSub n = TokSetN (r, readSubscript n)@@ -93,13 +95,13 @@ 	c:s'	-> inp' { lexInput    = s' 			, lexPrevChar = c 			}-	[]	-> __IMPOSSIBLE__+	[]	-> inp' { lexInput = [] }   -- we do get empty tokens moving between states --- | Alex can't handle unicode characters. To solve this we translate all---   Unicode (non-ASCII) identifiers to @z@, all Unicode operator---   characters to @+@, and all whitespace characters (except for @\t@---   and @\n@) to ' '. It is important that there aren't any keywords---   containing @z@, @+@ or @ @.+-- | Alex 2 can't handle unicode characters. To solve this we+--   translate all Unicode (non-ASCII) identifiers to @z@, all Unicode+--   operator characters to @+@, and all whitespace characters (except+--   for @\t@ and @\n@) to ' '. It is important that there aren't any+--   keywords containing @z@, @+@ or @ @. foolAlex :: AlexInput -> AlexInput foolAlex inp = inp { lexInput = map fool $ lexInput inp }     where

src/full/Agda/Syntax/Parser/LexActions.hs-boot view

@@ -27,4 +27,3 @@ followedBy    :: Char -> LexPredicate eof           :: LexPredicate inState       :: LexState -> LexPredicate-

src/full/Agda/Syntax/Parser/Lexer.x view

@@ -1,5 +1,6 @@ { {-# OPTIONS_GHC -fno-warn-deprecated-flags #-}+{-# LANGUAGE BangPatterns #-} {-| The lexer is generated by Alex (<http://www.haskell.org/alex>) and is an     adaptation of GHC's lexer. The main lexing function 'lexer' is called by     the "Agda.Syntax.Parser.Parser" to get the next token from the input.@@ -56,10 +57,11 @@ tokens :-  -- Lexing literate files-<tex>	 $white_nonl* \\ "begin{code}" $white_nonl* $ { end_ }-<tex>	 .* $		            { withInterval TokTeX }-<tex>	 .+		            { withInterval TokTeX }+<tex> $white_nonl* \\ "begin{code}" $white_nonl* $ { end_ }+<tex> .+ / { keepComments } { withInterval TokTeX }+<tex>	 .+		            ; <tex>    \n                         ;+<tex> () / { eof } { end_ } <bol_,layout_>   \\ "end{code}" / { inState code } { begin_ tex }   -- \end{code} should only be recognized if the bottom of the stack is <code>@@ -79,7 +81,9 @@ <pragma_>   "COMPILED_DATA"	{ keyword KwCOMPILED_DATA } <pragma_>   "COMPILED_TYPE"	{ keyword KwCOMPILED_TYPE } <pragma_>   "COMPILED"	        { keyword KwCOMPILED }-<pragma_>   "COMPILED_EPIC" { keyword KwCOMPILED_EPIC }+<pragma_>   "COMPILED_EPIC"     { keyword KwCOMPILED_EPIC }+<pragma_>   "COMPILED_JS"       { keyword KwCOMPILED_JS }+<pragma_>   "STATIC"            { keyword KwSTATIC } <pragma_>   "IMPORT"	        { keyword KwIMPORT } <pragma_>   "IMPOSSIBLE"	{ keyword KwIMPOSSIBLE } <pragma_>   "ETA"               { keyword KwETA }@@ -150,6 +154,8 @@ <0,code> Set @number	{ withInterval' (read . drop 3) TokSetN } <0,code> quoteGoal	{ keyword KwQuoteGoal } <0,code> quote		{ keyword KwQuote }+<0,code> quoteTerm	{ keyword KwQuoteTerm }+<0,code> unquote	{ keyword KwUnquote } <0,code> syntax         { keyword KwSyntax }  -- The parser is responsible to put the lexer in the imp_dir_ state when it@@ -166,6 +172,7 @@  -- Special symbols <0,code> "..."		{ symbol SymEllipsis }+<0,code> ".."		{ symbol SymDotDot } <0,code> "."		{ symbol SymDot } <0,code> ";"		{ symbol SymSemi } <0,code> ":"		{ symbol SymColon }@@ -178,6 +185,14 @@ <0,code> "->"		{ symbol SymArrow } <0,code> "\"		{ symbol SymLambda } <0,code> "@"		{ symbol SymAs }+<0,code> "{{" /[^!]		{ symbol SymDoubleOpenBrace }+-- We don't lex '}}' into a SymDoubleCloseBrace. Instead, we lex it as+-- two SymCloseBrace's. When the parser is looking for a double+-- closing brace, it will also accept two SymCloseBrace's, after+-- verifying that they are immediately next to each other.+-- This trick allows us to keep "record { a = record {}}" working+-- properly.+-- <0,code> "}}"		{ symbol SymDoubleCloseBrace } <0,code> "{"		{ symbol SymOpenBrace }	    -- you can't use braces for layout <0,code> "}"		{ symbol SymCloseBrace }

src/full/Agda/Syntax/Parser/Parser.y view

@@ -1,6 +1,7 @@ { {-# OPTIONS_GHC -fno-warn-incomplete-patterns                 -fno-warn-deprecated-flags #-}+{-# LANGUAGE BangPatterns #-} {-| The parser is generated by Happy (<http://www.haskell.org/happy>). -} module Agda.Syntax.Parser.Parser (@@ -33,7 +34,6 @@ import Agda.Utils.Monad import Agda.Utils.QuickCheck import Agda.Utils.TestHelpers- }  %name tokensParser Tokens@@ -89,14 +89,19 @@     'COMPILED_DATA' { TokKeyword KwCOMPILED_DATA $$ }     'COMPILED_TYPE' { TokKeyword KwCOMPILED_TYPE $$ }     'COMPILED_EPIC' { TokKeyword KwCOMPILED_EPIC $$ }+    'COMPILED_JS'   { TokKeyword KwCOMPILED_JS $$ }+    'STATIC'        { TokKeyword KwSTATIC $$ }     'quoteGoal'     { TokKeyword KwQuoteGoal $$ }     'quote'         { TokKeyword KwQuote $$ }+    'quoteTerm'     { TokKeyword KwQuoteTerm $$ }+    'unquote'       { TokKeyword KwUnquote $$ }      setN	{ TokSetN $$ }     tex		{ TokTeX $$ }     comment	{ TokComment $$ }      '...'	{ TokSymbol SymEllipsis $$ }+    '..'	{ TokSymbol SymDotDot $$ }     '.'		{ TokSymbol SymDot $$ }     ';'		{ TokSymbol SymSemi $$ }     ':'		{ TokSymbol SymColon $$ }@@ -109,6 +114,8 @@     '|'		{ TokSymbol SymBar $$ }     '('		{ TokSymbol SymOpenParen $$ }     ')'		{ TokSymbol SymCloseParen $$ }+    '{{'	{ TokSymbol SymDoubleOpenBrace $$ }+    '}}'	{ TokSymbol SymDoubleCloseBrace $$ }     '{'		{ TokSymbol SymOpenBrace $$ }     '}'		{ TokSymbol SymCloseBrace $$ }     vopen	{ TokSymbol SymOpenVirtualBrace $$ }@@ -179,16 +186,21 @@     | 'COMPILED_DATA'{ TokKeyword KwCOMPILED_DATA $1 }     | 'COMPILED_TYPE'{ TokKeyword KwCOMPILED_TYPE $1 }     | 'COMPILED_EPIC'{ TokKeyword KwCOMPILED_EPIC $1 }+    | 'COMPILED_JS'  { TokKeyword KwCOMPILED_JS $1 }+    | 'STATIC'       { TokKeyword KwSTATIC $1 }     | 'IMPOSSIBLE'    { TokKeyword KwIMPOSSIBLE $1 }     | 'ETA'           { TokKeyword KwETA $1 }     | 'quoteGoal'     { TokKeyword KwQuoteGoal $1 }     | 'quote'         { TokKeyword KwQuote $1 }+    | 'quoteTerm'     { TokKeyword KwQuoteTerm $1 }+    | 'unquote'       { TokKeyword KwUnquote $1 }      | setN	    { TokSetN $1 }     | tex	    { TokTeX $1 }     | comment	    { TokComment $1 }      | '...'	    { TokSymbol SymEllipsis $1 }+    | '..'	    { TokSymbol SymDotDot $1 }     | '.'	    { TokSymbol SymDot $1 }     | ';'	    { TokSymbol SymSemi $1 }     | ':'	    { TokSymbol SymColon $1 }@@ -201,6 +213,8 @@     | '|'	    { TokSymbol SymBar $1 }     | '('	    { TokSymbol SymOpenParen $1 }     | ')'	    { TokSymbol SymCloseParen $1 }+    | '{{'	    { TokSymbol SymDoubleOpenBrace $1 }+    | '}}'	    { TokSymbol SymDoubleCloseBrace $1 }     | '{'	    { TokSymbol SymOpenBrace $1 }     | '}'	    { TokSymbol SymCloseBrace $1 }     | vopen	    { TokSymbol SymOpenVirtualBrace $1 }@@ -216,22 +230,14 @@     | literal	    { TokLiteral $1 }  {---------------------------------------------------------------------------    TeX- --------------------------------------------------------------------------}--TeX :: { () }-TeX : {- empty -} { () }-    | tex TeX	  { () }--{--------------------------------------------------------------------------     Top level  --------------------------------------------------------------------------}  File :: { ([Pragma], [Declaration]) }-File : File1 TeX  { $1 }+File : File1 { $1 } -File1 : TopLevel		 { ([], $1) }-      | TeX TopLevelPragma File1 { let (ps,m) = $3 in ($2 : ps, m) }+File1 : TopLevel             { ([], $1) }+      | TopLevelPragma File1 { let (ps,m) = $2 in ($1 : ps, m) }   {--------------------------------------------------------------------------@@ -258,8 +264,8 @@ -- brace, so we don't have to distinguish between the two semi colons. You can't -- use a virtual semi colon in a block started by a concrete brace, but this is -- simply because the lexer will not generate virtual semis in this case.-semi : ';'	  { $1 }-     | TeX vsemi  { $2 }+semi : ';'    { $1 }+     | vsemi  { $1 }   -- Enter the 'imp_dir' lex state, where we can parse the keywords 'using',@@ -274,7 +280,7 @@ -- An integer. Used in fixity declarations. Int :: { Integer } Int : literal	{% case $1 of {-		     LitInt _ n	-> return $ fromIntegral n;+		     LitInt _ n	-> return n; 		     _		-> fail $ "Expected integer" 		   } 		}@@ -295,6 +301,23 @@     : Id SpaceIds { $1 : $2 }     | Id	  { [$1] } +-- When looking for a double closed brace, we accept either a single token '}}'+-- (which is what the unicode character "RIGHT WHITE CURLY BRACKET" is+-- postprocessed into in LexActions.hs), but also two consecutive tokens '}'+-- (which a string '}}' is lexed to).  This small hack allows us to keep+-- "record { a = record { }}" working. In the second case, we check that the two+-- tokens '}' are immediately consecutive.+DoubleCloseBrace :: { Range }+DoubleCloseBrace+  : '}}' { getRange $1 }+  | '}' '}' {%+      if posPos (fromJust (rEnd (getRange $2))) -+	 posPos (fromJust (rStart (getRange $1))) > 2+      then parseErrorAt (fromJust (rStart (getRange $2)))+	 "Expecting '}}', found separated '}'s."+      else return $ fuseRange (getRange $1) (getRange ($2))+    }+ {- UNUSED -- Space separated list of one or more identifiers, some of which may -- be surrounded by braces.@@ -302,6 +325,8 @@ HiddenIds     : Id HiddenIds               { defaultArg $1 : $2 }     | Id	                 { [defaultArg $1] }+    | '{{' SpaceIds DoubleCloseBrace HiddenIds { map (Arg Instance Relevant) $2 ++ $4 }+    | '{{' SpaceIds DoubleCloseBrace         { map (Arg Instance Relevant) $2 }     | '{' SpaceIds '}' HiddenIds { map (Arg Hidden Relevant) $2 ++ $4 }     | '{' SpaceIds '}'           { map (Arg Hidden Relevant) $2 } -}@@ -322,12 +347,20 @@ -- be surrounded by braces or dotted. ArgIds :: { [Arg Name] } ArgIds-    : MaybeDottedId ArgIds          { $1 : $2 }-    | MaybeDottedId                 { [$1] }-    | '{' MaybeDottedIds '}' ArgIds { map hide $2 ++ $4 }-    | '{' MaybeDottedIds '}'        { map hide $2 }-    | '.' '{' SpaceIds '}' ArgIds   { map (Arg Hidden Irrelevant) $3 ++ $5 }-    | '.' '{' SpaceIds '}'          { map (Arg Hidden Irrelevant) $3 }+    : MaybeDottedId ArgIds            { $1 : $2 }+    | MaybeDottedId                   { [$1] }+    | '{{' MaybeDottedIds DoubleCloseBrace ArgIds { map makeInstance $2 ++ $4 }+    | '{{' MaybeDottedIds DoubleCloseBrace        { map makeInstance $2 }+    | '{' MaybeDottedIds '}' ArgIds   { map hide $2 ++ $4 }+    | '{' MaybeDottedIds '}'          { map hide $2 }+    | '.' '{' SpaceIds '}' ArgIds     { map (Arg Hidden Irrelevant) $3 ++ $5 }+    | '.' '{' SpaceIds '}'            { map (Arg Hidden Irrelevant) $3 }+    | '.' '{{' SpaceIds DoubleCloseBrace ArgIds   { map (Arg Instance Irrelevant) $3 ++ $5 }+    | '.' '{{' SpaceIds DoubleCloseBrace          { map (Arg Instance Irrelevant) $3 }+    | '..' '{' SpaceIds '}' ArgIds    { map (Arg Hidden NonStrict) $3 ++ $5 }+    | '..' '{' SpaceIds '}'           { map (Arg Hidden NonStrict) $3 }+    | '..' '{{' SpaceIds DoubleCloseBrace ArgIds  { map (Arg Instance NonStrict) $3 ++ $5 }+    | '..' '{{' SpaceIds DoubleCloseBrace         { map (Arg Instance NonStrict) $3 }  QId :: { QName } QId : q_id  {% mkQName $1 }@@ -344,7 +377,16 @@ BId : Id    { $1 }     | '_'   { Name (getRange $1) [Hole] } +{- UNUSED+-- A binding variable. Can be '_'+MaybeDottedBId :: { (Relevance, Name) }+MaybeDottedBId+    : BId        { (Relevant  , $1) }+    | '.' BId    { (Irrelevant, $2) }+    | '..' BId   { (NonStrict, $2) }+-} + -- Space separated list of binding identifiers. Used in fixity -- declarations infixl 100 + - SpaceBIds :: { [Name] }@@ -352,12 +394,34 @@     : BId SpaceBIds { $1 : $2 }     | BId	    { [$1] } +{- DOES PRODUCE REDUCE/REDUCE CONFLICTS! -- Space-separated list of binding identifiers. Used in dependent -- function spaces: (x y z : Nat) -> ... -- (Used to be comma-separated; hence the name) -- QUESTION: Should this be replaced by SpaceBIds above?+--CommaBIds :: { [(Relevance,Name)] } CommaBIds :: { [Name] }-CommaBIds : Application {%+CommaBIds+    : CommaBIds BId { $1 ++ [$2] }  -- SWITCHING DOES NOT HELP+    | BId	    { [$1] }+-}++-- Space-separated list of binding identifiers. Used in dependent+-- function spaces: (x y z : Nat) -> ...+-- (Used to be comma-separated; hence the name)+-- QUESTION: Should this be replaced by SpaceBIds above?+-- Andreas, 2011-04-07 the trick avoids reduce/reduce conflicts+-- when parsing  (x y z : A) -> B+-- at point (x y  it is not clear whether x y is an application or+-- a variable list. We could be parsing (x y z) -> B+-- with ((x y) z) being a type.+CommaBIds :: { [Name] }+CommaBIds : CommaBIdAndAbsurds {+    case $1 of+      Left ns -> ns+      Right _ -> fail $ "expected sequence of bound identifiers, not absurd pattern"+    }+{-     let getName (Ident (QName x)) = Just x 	getName (Underscore r _)  = Just (Name r [Hole]) 	getName _		  = Nothing@@ -365,6 +429,25 @@     case partition isJust $ map getName $1 of 	(good, []) -> return $ map fromJust good 	_	   -> fail $ "expected sequence of bound identifiers"+-}++CommaBIdAndAbsurds :: { Either [Name] [Expr] }+CommaBIdAndAbsurds : Application {%+    let getName (Ident (QName x)) = Just x+	getName (Underscore r _)  = Just (Name r [Hole])+	getName _		  = Nothing++        containsAbsurd (Absurd _) = True+        containsAbsurd (HiddenArg _ (Named _ e)) = containsAbsurd e+        containsAbsurd (InstanceArg _ (Named _ e)) = containsAbsurd e+        containsAbsurd (Paren _ expr)    = containsAbsurd expr+        containsAbsurd (RawApp _ exprs)    = any containsAbsurd exprs+        containsAbsurd _          = False+    in+    if isJust $ find containsAbsurd $1 then return $ Right $1 else+    case partition isJust $ map getName $1 of+	(good, []) -> return $ Left $ map fromJust good+	_	   -> fail $ "expected sequence of bound identifiers"     }  @@ -427,9 +510,15 @@ -- Level 2: Lambdas and lets Expr2     : '\\' LamBindings Expr	   { Lam (fuseRange $1 $3) $2 $3 }-    | '\\' AbsurdLamBindings       { let (bs, h) = $2; r = fuseRange $1 bs in-                                     if null bs then AbsurdLam r h else-                                     Lam r bs (AbsurdLam r h)+    | '\\'  '{' LamClauses '}'     { ExtendedLam (fuseRange $1 (fuseRange $2 $4)) (reverse $3) }+    | '\\' AbsurdLamBindings       {% case $2 of+                                       Left (bs, h) -> if null bs then return $ AbsurdLam r h else+                                                       return $ Lam r bs (AbsurdLam r h)+                                                         where r = fuseRange $1 bs+    				       Right es -> do -- it is of the form @\ { p1 ... () }@+                                                     p <- exprToLHS (RawApp (getRange es) es);+                                                     return $ ExtendedLam (fuseRange $1 es)+                                                                     [(p [] [], AbsurdRHS, NoWhere)]                                    }     | 'let' Declarations 'in' Expr { Let (fuseRange $1 $4) $2 $4 }     | Expr3			   { $1 }@@ -441,7 +530,12 @@     | Expr3 Application3 { $1 : $2 }  -- Level 3: Atoms-Expr3+Expr3Curly+    : '{' Expr '}'			{ HiddenArg (fuseRange $1 $3) (unnamed $2) }+    | '{' Id '=' Expr '}'		{ HiddenArg (fuseRange $1 $5) (named (show $2) $4) }+    | '{' '}'				{ let r = fuseRange $1 $2 in HiddenArg r $ unnamed $ Absurd r }++Expr3NoCurly     : QId				{ Ident $1 }     | literal				{ Lit $1 }     | '?'				{ QuestionMark (getRange $1) Nothing }@@ -449,16 +543,22 @@     | 'Prop'				{ Prop (getRange $1) }     | 'Set'				{ Set (getRange $1) }     | 'quote'                           { Quote (getRange $1) }+    | 'quoteTerm'                       { QuoteTerm (getRange $1) }+    | 'unquote'                         { Unquote (getRange $1) }     | setN				{ SetN (getRange (fst $1)) (snd $1) }-    | '{' Expr '}'			{ HiddenArg (fuseRange $1 $3) (unnamed $2) }-    | '{' Id '=' Expr '}'		{ HiddenArg (fuseRange $1 $5) (named (show $2) $4) }+    | '{{' Expr DoubleCloseBrace			{ InstanceArg (fuseRange $1 $3) (unnamed $2) }+    | '{{' Id '=' Expr DoubleCloseBrace		{ InstanceArg (fuseRange $1 $5) (named (show $2) $4) }     | '(' Expr ')'			{ Paren (fuseRange $1 $3) $2 }-    | '{' '}'				{ let r = fuseRange $1 $2 in HiddenArg r $ unnamed $ Absurd r }     | '(' ')'				{ Absurd (fuseRange $1 $2) }+    | '{{' DoubleCloseBrace             { let r = fuseRange $1 $2 in InstanceArg r $ unnamed $ Absurd r }     | Id '@' Expr3			{ As (fuseRange $1 $3) $1 $3 }     | '.' Expr3				{ Dot (fuseRange $1 $2) $2 }     | 'record' '{' FieldAssignments '}' { Rec (getRange ($1,$4)) $3 }+    | 'record' Expr3NoCurly '{' FieldAssignments '}' { RecUpdate (getRange ($1,$5)) $2 $4 } +Expr3+    : Expr3Curly			{ $1 }+    | Expr3NoCurly			{ $1 }  FieldAssignments :: { [(Name, Expr)] } FieldAssignments@@ -490,22 +590,20 @@     | TypedBindings		   { [$1] }  --- A typed binding is either (x1 .. xn:A;..;y1 .. ym:B) or {x1 .. xn:A;..;y1 .. ym:B}.+-- A typed binding is either (x1 .. xn : A) or   {y1 .. ym : B}+-- Andreas, 2011-04-07: or  .(x1 .. xn : A) or  .{y1 .. ym : B}+-- Andreas, 2011-04-27: or ..(x1 .. xn : A) or ..{y1 .. ym : B} TypedBindings :: { TypedBindings } TypedBindings-    : '(' TBinds ')' { TypedBindings (fuseRange $1 $3) (Arg NotHidden Relevant $2) }-    | '{' TBinds '}' { TypedBindings (fuseRange $1 $3) (Arg Hidden    Relevant $2) }----- A semicolon separated list of TypedBindings-TBinds :: { [TypedBinding] }-TBinds : TBind		   { [$1] }-       | TBind ';' TBinds2 { $1 : $3 }--TBinds2 :: { [TypedBinding] }-TBinds2 : TBinds	   { $1 }-	| Expr ';' TBinds2 { TNoBind $1 : $3 }-	| Expr		   { [TNoBind $1] }+    : '.' '(' TBind ')'    { TypedBindings (fuseRange $2 $4) (Arg NotHidden         Irrelevant $3) }+    | '.' '{' TBind '}'    { TypedBindings (fuseRange $2 $4) (Arg Hidden            Irrelevant $3) }+    | '.' '{{' TBind DoubleCloseBrace  { TypedBindings (fuseRange $1 $3) (Arg Instance Irrelevant $3) }+    | '..' '(' TBind ')'    { TypedBindings (fuseRange $2 $4) (Arg NotHidden         NonStrict $3) }+    | '..' '{' TBind '}'    { TypedBindings (fuseRange $2 $4) (Arg Hidden            NonStrict $3) }+    | '..' '{{' TBind DoubleCloseBrace  { TypedBindings (fuseRange $1 $3) (Arg Instance NonStrict $3) }+    | '(' TBind ')'        { TypedBindings (fuseRange $1 $3) (Arg NotHidden         Relevant $2) }+    | '{{' TBind DoubleCloseBrace      { TypedBindings (fuseRange $1 $3) (Arg Instance Relevant $2) }+    | '{' TBind '}'        { TypedBindings (fuseRange $1 $3) (Arg Hidden            Relevant $2) }   -- x1 .. xn:A@@ -517,30 +615,79 @@ LamBindings :: { [LamBinding] } LamBindings   : LamBinds '->' {%-      case last $1 of-        Left _  -> parseError "Absurd lambda cannot have a body."-        _       -> return [ b | Right b <- $1 ]+      case reverse $1 of+        Left _ : _ -> parseError "Absurd lambda cannot have a body."+	_ : _      -> return [ b | Right b <- $1 ]+        []         -> parsePanic "Empty LamBinds"       } -AbsurdLamBindings :: { ([LamBinding], Hiding) }+AbsurdLamBindings :: { Either ([LamBinding], Hiding) [Expr] } AbsurdLamBindings-  : LamBinds {%-    case last $1 of-      Right _ -> parseError "Missing body for lambda"-      Left h  -> return ([ b | Right b <- init $1], h)+  : LamBindsAbsurd {%+    case $1 of+      Left lb -> case reverse lb of+                   Right _ : _ -> parseError "Missing body for lambda"+                   Left h  : _ -> return $ Left ([ b | Right b <- init lb], h)+                   _           -> parsePanic "Empty LamBindsAbsurd"+      Right es -> return $ Right es     }  -- absurd lambda is represented by Left hiding LamBinds :: { [Either Hiding LamBinding] } LamBinds-  : DomainFreeBinding LamBinds	{ map Right $1 ++ $2 }-  | TypedBindings LamBinds	{ Right (DomainFull $1) : $2 }-  | DomainFreeBinding		{ map Right $1 }+  : DomainFreeBinding LamBinds  { map Right $1 ++ $2 }+  | TypedBindings LamBinds      { Right (DomainFull $1) : $2 }+  | DomainFreeBinding           { map Right $1 }   | TypedBindings		{ [Right $ DomainFull $1] }   | '(' ')'                     { [Left NotHidden] }   | '{' '}'                     { [Left Hidden] }+  | '{{' DoubleCloseBrace       { [Left Instance] } +-- Like LamBinds, but could also parse an absurd LHS of an extended lambda @{ p1 ... () }@+LamBindsAbsurd :: { Either [Either Hiding LamBinding] [Expr] }+LamBindsAbsurd+  : DomainFreeBinding LamBinds	{ Left $ map Right $1 ++ $2 }+  | TypedBindings LamBinds	{ Left $ Right (DomainFull $1) : $2 }+  | DomainFreeBindingAbsurd   	{ case $1 of+                                    Left lb -> Left $ map Right lb+                                    Right es -> Right es }+  | TypedBindings		{ Left [Right $ DomainFull $1] }+  | '(' ')'                     { Left [Left NotHidden] }+  | '{' '}'                     { Left [Left Hidden] }+  | '{{' DoubleCloseBrace       { Left [Left Instance] } +-- FNF, 2011-05-05: No where clauses in extended lambdas for now+NonAbsurdLamClause :: { (LHS,RHS,WhereClause) }+NonAbsurdLamClause+  : Application3 '->' Expr {% do+      p <- exprToLHS (RawApp (getRange $1) $1) ;+      return (p [] [], RHS $3, NoWhere)+	}++AbsurdLamClause :: { (LHS,RHS,WhereClause) }+AbsurdLamClause+-- FNF, 2011-05-09: By being more liberal here, we avoid shift/reduce and reduce/reduce errors.+-- Later stages such as scope checking will complain if we let something through which we should not+  : Application {% do+      p <- exprToLHS (RawApp (getRange $1) $1);+      return (p [] [], AbsurdRHS, NoWhere)+	}++LamClause :: { (LHS,RHS,WhereClause) }+LamClause+  : NonAbsurdLamClause { $1 }+  | AbsurdLamClause { $1 }++-- Parses all extended lambda clauses except for a single absurd clause, which is taken care of+-- in AbsurdLambda+LamClauses :: { [(LHS,RHS,WhereClause)] }+LamClauses+   : LamClauses semi LamClause { $3 : $1 }+   | AbsurdLamClause semi LamClause { [$3, $1] }+   | NonAbsurdLamClause { [$1] }+--   | {- empty -} { [] }++ ForallBindings :: { [LamBinding] } ForallBindings   : TypedUntypedBindings1 '->' { $1 }@@ -564,10 +711,37 @@ -- A domain free binding is either x or {x1 .. xn} DomainFreeBinding :: { [LamBinding] } DomainFreeBinding-    : BId		{ [DomainFree NotHidden $ mkBoundName_ $1]  }-    | '{' CommaBIds '}' { map (DomainFree Hidden . mkBoundName_) $2 }+  : DomainFreeBindingAbsurd { case $1 of+                             Left lbs -> lbs+                             Right _ -> fail "expected sequence of bound identifiers, not absurd pattern"+                          }+{-    : BId		{ [DomainFree NotHidden Relevant $ mkBoundName_ $1]  }+    | '.' BId		{ [DomainFree NotHidden Irrelevant $ mkBoundName_ $2]  }+    | '..' BId		{ [DomainFree NotHidden NonStrict $ mkBoundName_ $2]  }+    | '{' CommaBIds '}' { map (DomainFree Hidden Relevant . mkBoundName_) $2 }+    | '{{' CommaBIds DoubleCloseBrace { map (DomainFree Instance Relevant . mkBoundName_) $2 }+    | '.' '{' CommaBIds '}' { map (DomainFree Hidden Irrelevant . mkBoundName_) $3 }+    | '.' '{{' CommaBIds DoubleCloseBrace { map (DomainFree Instance Irrelevant . mkBoundName_) $3 }+    | '..' '{' CommaBIds '}' { map (DomainFree Hidden NonStrict . mkBoundName_) $3 }+    | '..' '{{' CommaBIds DoubleCloseBrace { map (DomainFree Instance NonStrict . mkBoundName_) $3 }+    | '..' '{{' CommaBIds DoubleCloseBrace { map (DomainFree Instance NonStrict . mkBoundName_) $3 }+  -} +-- A domain free binding is either x or {x1 .. xn}+DomainFreeBindingAbsurd :: { Either [LamBinding] [Expr]}+DomainFreeBindingAbsurd+    : BId		{ Left [DomainFree NotHidden Relevant $ mkBoundName_ $1]  }+    | '.' BId		{ Left [DomainFree NotHidden Irrelevant $ mkBoundName_ $2]  }+    | '..' BId		{ Left [DomainFree NotHidden NonStrict $ mkBoundName_ $2]  }+    | '{' CommaBIdAndAbsurds '}'+         { either (Left . map (DomainFree Hidden Relevant . mkBoundName_)) Right $2 }+    | '{{' CommaBIds DoubleCloseBrace { Left $ map (DomainFree Instance Relevant . mkBoundName_) $2 }+    | '.' '{' CommaBIds '}' { Left $ map (DomainFree Hidden Irrelevant . mkBoundName_) $3 }+    | '.' '{{' CommaBIds DoubleCloseBrace { Left $ map (DomainFree Instance Irrelevant . mkBoundName_) $3 }+    | '..' '{' CommaBIds '}' { Left $ map (DomainFree Hidden NonStrict . mkBoundName_) $3 }+    | '..' '{{' CommaBIds DoubleCloseBrace { Left $ map (DomainFree Instance NonStrict . mkBoundName_) $3 } + {--------------------------------------------------------------------------     Modules and imports  --------------------------------------------------------------------------}@@ -687,7 +861,9 @@     | Fields        { $1   }     | FunClause	    { [$1] }     | Data	    { [$1] }+    | DataSig	    { [$1] }  -- lone data type signature in mutual block     | Record	    { [$1] }+    | RecordSig	    { [$1] }  -- lone record signature in mutual block     | Infix	    { [$1] }     | Mutual	    { [$1] }     | Abstract	    { [$1] }@@ -738,17 +914,35 @@ -- Data declaration. Can be local. Data :: { Declaration } Data : 'data' Id TypedUntypedBindings ':' Expr 'where'-	    Constructors	{ Data (getRange ($1, $6, $7)) Inductive $2 (map addType $3) $5 $7 }+            Constructors	{ Data (getRange ($1, $6, $7)) Inductive $2 $3 (Just $5) $7 }      | 'codata' Id TypedUntypedBindings ':' Expr 'where'-	    Constructors	{ Data (getRange ($1, $6, $7)) CoInductive $2 (map addType $3) $5 $7 }+            Constructors	{ Data (getRange ($1, $6, $7)) CoInductive $2 $3 (Just $5) $7 } +  -- New cases when we already had a DataSig.  Then one can omit the sort.+     | 'data' Id TypedUntypedBindings 'where'+	    Constructors	{ Data (getRange ($1, $4, $5)) Inductive $2 $3 Nothing $5 }+     | 'codata' Id TypedUntypedBindings 'where'+	    Constructors	{ Data (getRange ($1, $4, $5)) CoInductive $2 $3 Nothing $5 } +-- Data type signature. Found in mutual blocks.+DataSig :: { Declaration }+DataSig : 'data' Id TypedUntypedBindings ':' Expr+  { DataSig (fuseRange $1 $5) Inductive $2 $3 $5 }+ -- Record declarations. Record :: { Declaration } Record : 'record' Id TypedUntypedBindings ':' Expr 'where' 	    RecordDeclarations-         { Record (getRange ($1, $6, $7)) $2 (fst $7) (map addType $3) $5 (snd $7) }+         { Record (getRange ($1, $6, $7)) $2 (fst $7) $3 (Just $5) (snd $7) }+       | 'record' Id TypedUntypedBindings 'where'+	    RecordDeclarations+         { Record (getRange ($1, $4, $5)) $2 (fst $5) $3 Nothing (snd $5) } +-- Record type signature. In mutual blocks.+RecordSig :: { Declaration }+RecordSig : 'record' Id TypedUntypedBindings ':' Expr+  { RecordSig (fuseRange $1 $5) $2 $3 $5 }+ -- Declaration of record constructor name. RecordConstructorName :: { Name } RecordConstructorName : 'constructor' Id { $2 }@@ -827,22 +1021,38 @@     } in     case es of     { []  -> Open r m dir-    ; _   -> Private r [ ModuleMacro r (noName $ beginningOf $ getRange $2) []-                           (RawApp (fuseRange m es) (Ident m : es)) DoOpen dir+	; _   -> Private r [ ModuleMacro r (noName $ beginningOf $ getRange $2)+			     (SectionApp (getRange (m , es)) [] (RawApp (fuseRange m es) (Ident m : es)))+			     DoOpen dir                        ]     }   }+  | 'open' ModuleName '{{' '...' DoubleCloseBrace ImportDirective {+    let r = getRange ($1, $2, $3, $4) in+    Private r [ ModuleMacro r (noName $ beginningOf $ getRange $2)+    	      	(RecordModuleIFS r $2) DoOpen $6+        ]+  }  OpenArgs :: { [Expr] } OpenArgs : {- empty -}    { [] }          | Expr3 OpenArgs { $1 : $2 } +ModuleApplication :: { [TypedBindings] -> Parser ModuleApplication }+ModuleApplication : ModuleName '{{' '...' DoubleCloseBrace { (\ts ->+		    if null ts then return $ RecordModuleIFS (getRange ($1, $4)) $1+		    else parseError "No bindings allowed for record module with non-canonical implicits" )+		    }+		  | ModuleName OpenArgs {+		    (\ts -> return $ SectionApp (getRange ($1, $2)) ts (RawApp (fuseRange $1 $2) (Ident $1 : $2)) ) }++ -- Module instantiation ModuleMacro :: { Declaration }-ModuleMacro : 'module' Id TypedUntypedBindings '=' Expr ImportDirective-		    { ModuleMacro (getRange ($1, $5, $6)) $2 (map addType $3) $5 DontOpen $6 }-	    | 'open' 'module' Id TypedUntypedBindings '=' Expr ImportDirective-		    { ModuleMacro (getRange ($1, $6, $7)) $3 (map addType $4) $6 DoOpen $7 }+ModuleMacro : 'module' Id TypedUntypedBindings '=' ModuleApplication ImportDirective+		    {% do {ma <- $5 (map addType $3); return $ ModuleMacro (getRange ($1, ma, $6)) $2 ma DontOpen $6 } }+	    | 'open' 'module' Id TypedUntypedBindings '=' ModuleApplication ImportDirective+		    {% do {ma <- $6 (map addType $4); return $ ModuleMacro (getRange ($1, ma, $7)) $3 ma DoOpen $7 } }  -- Import Import :: { Declaration }@@ -858,9 +1068,9 @@  -- The top-level consist of a bunch of import and open followed by a top-level module. TopLevel :: { [Declaration] }-TopLevel : TeX TopModule       { [$2] }-	 | TeX Import TopLevel { $2 : $3 }-	 | TeX Open   TopLevel { $2 : $3 }+TopLevel : TopModule       { [$1] }+	 | Import TopLevel { $1 : $2 }+	 | Open   TopLevel { $1 : $2 }  -- The top-level module can have a qualified name. TopModule :: { Declaration }@@ -881,6 +1091,8 @@   | CompiledDataPragma { $1 }   | CompiledTypePragma { $1 }   | CompiledEpicPragma { $1 }+  | CompiledJSPragma   { $1 }+  | StaticPragma       { $1 }   | ImportPragma       { $1 }   | ImpossiblePragma   { $1 }   | RecordEtaPragma    { $1 }@@ -913,7 +1125,16 @@   : '{-#' 'COMPILED_EPIC' PragmaName PragmaStrings '#-}'     { CompiledEpicPragma (fuseRange $1 $5) $3 (unwords $4) } +CompiledJSPragma :: { Pragma }+CompiledJSPragma+  : '{-#' 'COMPILED_JS' PragmaName PragmaStrings '#-}'+    { CompiledJSPragma (fuseRange $1 $5) $3 (unwords $4) } +StaticPragma :: { Pragma }+StaticPragma+  : '{-#' 'STATIC' PragmaName '#-}'+    { StaticPragma (fuseRange $1 $4) $3 }+ RecordEtaPragma :: { Pragma } RecordEtaPragma   : '{-#' 'ETA' PragmaName '#-}'@@ -939,66 +1160,66 @@ -- for every signature. TypeSignatures :: { [TypeSignature] } TypeSignatures-    : TeX vopen TypeSignatures1 TeX close   { reverse $3 }+    : vopen TypeSignatures1 close   { reverse $2 }  -- Inside the layout block. TypeSignatures1 :: { [TypeSignature] } TypeSignatures1-    : TypeSignatures1 semi TeX TypeSigs { reverse $4 ++ $1 }-    | TeX TypeSigs			{ reverse $2 }+    : TypeSignatures1 semi TypeSigs { reverse $3 ++ $1 }+    | TypeSigs                      { reverse $1 }  -- A variant of TypeSignatures which allows the irrelevance annotation (dot). RelTypeSignatures :: { [TypeSignature] } RelTypeSignatures-    : TeX vopen RelTypeSignatures1 TeX close   { reverse $3 }+    : vopen RelTypeSignatures1 close   { reverse $2 }  -- Inside the layout block. RelTypeSignatures1 :: { [TypeSignature] } RelTypeSignatures1-    : RelTypeSignatures1 semi TeX RelTypeSigs { reverse $4 ++ $1 }-    | TeX RelTypeSigs			      { reverse $2 }+    : RelTypeSignatures1 semi RelTypeSigs { reverse $3 ++ $1 }+    | RelTypeSigs                         { reverse $1 }  -- A variant of TypeSignatures which uses ArgTypeSigs instead of -- TypeSigs. ArgTypeSignatures :: { [Arg TypeSignature] } ArgTypeSignatures-    : TeX vopen ArgTypeSignatures1 TeX close   { reverse $3 }+    : vopen ArgTypeSignatures1 close   { reverse $2 }  -- Inside the layout block. ArgTypeSignatures1 :: { [Arg TypeSignature] } ArgTypeSignatures1-    : ArgTypeSignatures1 semi TeX ArgTypeSigs { reverse $4 ++ $1 }-    | TeX ArgTypeSigs		              { reverse $2 }+    : ArgTypeSignatures1 semi ArgTypeSigs { reverse $3 ++ $1 }+    | ArgTypeSigs                         { reverse $1 }  -- Constructors are type signatures. But constructor lists can be empty. Constructors :: { [Constructor] } Constructors-    : TeX vopen TeX close { [] }-    | TypeSignatures	  { $1 }+    : vopen close    { [] }+    | TypeSignatures { $1 }  -- Record declarations, including an optional record constructor name. RecordDeclarations :: { (Maybe Name, [Declaration]) } RecordDeclarations-    : TeX vopen                                              TeX close { (Nothing, []) }-    | TeX vopen TeX RecordConstructorName                    TeX close { (Just $4, []) }-    | TeX vopen TeX RecordConstructorName semi Declarations1 TeX close { (Just $4, reverse $6) }-    | TeX vopen                                Declarations1 TeX close { (Nothing, reverse $3) }+    : vopen                                          close { (Nothing, []) }+    | vopen RecordConstructorName                    close { (Just $2, []) }+    | vopen RecordConstructorName semi Declarations1 close { (Just $2, reverse $4) }+    | vopen                            Declarations1 close { (Nothing, reverse $2) }  -- Arbitrary declarations Declarations :: { [Declaration] } Declarations-    : TeX vopen Declarations1 TeX close { reverse $3 }+    : vopen Declarations1 close { reverse $2 }  -- Arbitrary declarations Declarations0 :: { [Declaration] } Declarations0-    : TeX vopen TeX close  { [] }+    : vopen close  { [] }     | Declarations { $1 }  Declarations1 :: { [Declaration] } Declarations1-    : Declarations1 semi TeX Declaration { reverse $4 ++ $1 }-    | TeX Declaration			 { reverse $2 }+    : Declarations1 semi Declaration { reverse $3 ++ $1 }+    | Declaration                    { reverse $1 }   {@@ -1074,7 +1295,7 @@ -- | Converts lambda bindings to typed bindings. addType :: LamBinding -> TypedBindings addType (DomainFull b)	 = b-addType (DomainFree h x) = TypedBindings r $ Arg h Relevant [TBind r [x] $ Underscore r Nothing]+addType (DomainFree h rel x) = TypedBindings r $ Arg h rel $ TBind r [x] $ Underscore r Nothing   where r = getRange x  -- | Check that an import directive doesn't contain repeated names@@ -1163,11 +1384,18 @@ 	Dot r e			-> return $ DotP r e 	Lit l			-> return $ LitP l 	HiddenArg r e		-> HiddenP r <$> T.mapM exprToPattern e+	InstanceArg r e		-> InstanceP r <$> T.mapM exprToPattern e 	RawApp r es		-> RawAppP r <$> mapM exprToPattern es-	OpApp r x es		-> OpAppP r x <$> mapM exprToPattern es+	OpApp r x es		-> OpAppP r x <$> mapM opAppExprToPattern es 	_			->           let Just pos = rStart $ getRange e in           parseErrorAt pos $ "Not a valid pattern: " ++ show e++opAppExprToPattern :: OpApp Expr -> Parser Pattern+opAppExprToPattern (SyntaxBindingLambda _ _ _) = parseError "syntax binding lambda cannot appear in a pattern"+opAppExprToPattern (Ordinary e) = exprToPattern e++parsePanic s = parseError $ "Internal parser error: " ++ s ++ ". Please report this as a bug."  {--------------------------------------------------------------------------     Tests

src/full/Agda/Syntax/Parser/Tokens.hs view

@@ -18,8 +18,9 @@ 	| KwSet | KwProp | KwForall | KwRecord | KwConstructor | KwField 	| KwHiding | KwUsing | KwRenaming | KwTo | KwPublic 	| KwOPTIONS | KwBUILTIN | KwLINE-        | KwCOMPILED_DATA | KwCOMPILED_TYPE | KwCOMPILED | KwCOMPILED_EPIC | KwIMPORT-        | KwIMPOSSIBLE | KwETA | KwQuoteGoal | KwQuote | KwSyntax+	| KwCOMPILED_DATA | KwCOMPILED_TYPE | KwCOMPILED | KwCOMPILED_EPIC | KwCOMPILED_JS+	| KwIMPORT | KwIMPOSSIBLE | KwETA | KwSTATIC+	| KwQuoteGoal | KwQuote | KwQuoteTerm | KwUnquote | KwSyntax     deriving (Eq, Show)  layoutKeywords :: [Keyword]@@ -31,9 +32,10 @@ 	| SymColon | SymArrow | SymEqual | SymLambda 	| SymUnderscore	| SymQuestionMark   | SymAs 	| SymOpenParen	      | SymCloseParen+	| SymDoubleOpenBrace  | SymDoubleCloseBrace 	| SymOpenBrace	      | SymCloseBrace 	| SymOpenVirtualBrace | SymCloseVirtualBrace-	| SymOpenPragma	      | SymClosePragma | SymEllipsis+	| SymOpenPragma	      | SymClosePragma | SymEllipsis | SymDotDot     deriving (Eq, Show)  data Token

src/full/Agda/Syntax/Position.hs view

@@ -305,7 +305,9 @@ fuseIntervals x y = Interval { iStart = head ps, iEnd = last ps }     where ps = sort [iStart x, iStart y, iEnd x, iEnd y] --- | Finds a range which covers the arguments.+-- | @fuseRanges r r'@ unions the ranges @r@ and @r'@.+--+--   Meaning it finds the least range @r0@ that covers @r@ and @r'@. fuseRanges :: Range -> Range -> Range fuseRanges (Range is) (Range js) = Range (helper is js)   where

src/full/Agda/Syntax/Scope/Base.hs view

@@ -1,9 +1,10 @@-{-# LANGUAGE CPP, DeriveDataTypeable, GADTs, ScopedTypeVariables #-}+{-# LANGUAGE CPP, DeriveDataTypeable, GADTs, ScopedTypeVariables, TupleSections #-}  {-| This module defines the notion of a scope and operations on scopes. -} module Agda.Syntax.Scope.Base where +import Control.Arrow ((***), (&&&)) import Control.Applicative import Data.Generics (Typeable, Data) import Data.List@@ -20,6 +21,7 @@   (ImportDirective(..), UsingOrHiding(..), ImportedName(..), Renaming(..)) import qualified Agda.Utils.Map as Map import Agda.Utils.Tuple+import Agda.Utils.List  #include "../../undefined.h" import Agda.Utils.Impossible@@ -29,30 +31,27 @@ -- | A scope is a named collection of names partitioned into public and private --   names. data Scope = Scope-      { scopeName     :: A.ModuleName-      , scopeParents  :: [A.ModuleName]-      , scopePrivate  :: NameSpace-      , scopePublic   :: NameSpace-      , scopeImported :: NameSpace -- ^ public opened names-      , scopeImports  :: Map C.QName A.ModuleName+      { scopeName          :: A.ModuleName+      , scopeParents       :: [A.ModuleName]+      , scopeNameSpaces    :: [(NameSpaceId, NameSpace)]+      , scopeImports       :: Map C.QName A.ModuleName       }   deriving (Typeable, Data) -data NameSpaceId = PrivateNS | PublicNS | ImportedNS-  deriving (Typeable, Data, Eq)+data NameSpaceId = PrivateNS | PublicNS | ImportedNS | OnlyQualifiedNS+  deriving (Typeable, Data, Eq, Bounded, Enum)  localNameSpace :: Access -> NameSpaceId localNameSpace PublicAccess  = PublicNS localNameSpace PrivateAccess = PrivateNS+localNameSpace OnlyQualified = OnlyQualifiedNS -importedNameSpace :: Access -> NameSpaceId-importedNameSpace PublicAccess  = ImportedNS-importedNameSpace PrivateAccess = PrivateNS+nameSpaceAccess :: NameSpaceId -> Access+nameSpaceAccess PrivateNS = PrivateAccess+nameSpaceAccess _         = PublicAccess  scopeNameSpace :: NameSpaceId -> Scope -> NameSpace-scopeNameSpace PublicNS   = scopePublic-scopeNameSpace PrivateNS  = scopePrivate-scopeNameSpace ImportedNS = scopeImported+scopeNameSpace ns s = maybe __IMPOSSIBLE__ id $ lookup ns $ scopeNameSpaces s  -- | The complete information about the scope at a particular program point --   includes the scope stack, the local variables, and the context precedence.@@ -92,6 +91,9 @@   NameTag   -> nsNames   ModuleTag -> nsModules +instance KillRange ScopeInfo where+  killRange m = m+ instance InScope AbstractName where   inScopeTag = NameTag @@ -146,13 +148,11 @@ blockOfLines hd ss = hd : map ("  "++) ss  instance Show Scope where-  show (Scope { scopeName = name, scopeParents = parents, scopeImports = imps-              , scopePublic = pub, scopePrivate = pri, scopeImported = imp }) =+  show (scope @ Scope { scopeName = name, scopeParents = parents, scopeImports = imps }) =     unlines $       [ "* scope " ++ show name ] ++ ind (-         blockOfLines "public"   (lines $ show pub)-      ++ blockOfLines "imported" (lines $ show imp)-      ++ blockOfLines "private"  (lines $ show pri)+        concat [ blockOfLines (show nsid) (lines $ show $ scopeNameSpace nsid scope)+               | nsid <- [minBound..maxBound] ]       ++ blockOfLines "imports"  (case Map.keys imps of                                     [] -> []                                     ks -> [ show ks ]@@ -160,6 +160,13 @@       )     where ind = map ("  " ++) +instance Show NameSpaceId where+  show nsid = case nsid of+    PublicNS        -> "public"+    PrivateNS       -> "private"+    ImportedNS      -> "imported"+    OnlyQualifiedNS -> "only-qualified"+ instance Show NameSpace where   show (NameSpace names mods) =     unlines $@@ -185,7 +192,7 @@  -- * Operations on name and module maps. -mergeNames :: InScope a => ThingsInScope a -> ThingsInScope a -> ThingsInScope a+mergeNames :: Eq a => ThingsInScope a -> ThingsInScope a -> ThingsInScope a mergeNames = Map.unionWith union  -- * Operations on name spaces@@ -227,12 +234,10 @@  -- | The empty scope. emptyScope :: Scope-emptyScope = Scope { scopeName	   = noModuleName-                   , scopeParents  = []-		   , scopePublic   = emptyNameSpace-		   , scopePrivate  = emptyNameSpace-                   , scopeImported = emptyNameSpace-                   , scopeImports  = Map.empty+emptyScope = Scope { scopeName	     = noModuleName+                   , scopeParents    = []+		   , scopeNameSpaces = [ (nsid, emptyNameSpace) | nsid <- [minBound..maxBound] ]+                   , scopeImports    = Map.empty 		   }  -- | The empty scope info.@@ -249,10 +254,7 @@ 	    (NameSpaceId -> ModulesInScope -> ModulesInScope) -> 	    Scope -> Scope mapScope fd fm s =-  s { scopePrivate  = mapNS PrivateNS  $ scopePrivate  s-    , scopePublic   = mapNS PublicNS   $ scopePublic   s-    , scopeImported = mapNS ImportedNS $ scopeImported s-    }+  s { scopeNameSpaces = [ (nsid, mapNS nsid ns) | (nsid, ns) <- scopeNameSpaces s ] }   where     mapNS acc = mapNameSpace (fd acc) (fm acc) @@ -263,21 +265,19 @@ mapScope_ fd fm = mapScope (const fd) (const fm)  -- | Map monadic functions over the names and modules in a scope.-mapScopeM :: Monad m =>+mapScopeM :: (Functor m, Monad m) =>   (NameSpaceId -> NamesInScope   -> m NamesInScope  ) ->   (NameSpaceId -> ModulesInScope -> m ModulesInScope) ->   Scope -> m Scope mapScopeM fd fm s = do-  pri <- mapNS PrivateNS  $ scopePrivate  s-  pub <- mapNS PublicNS   $ scopePublic   s-  imp <- mapNS ImportedNS $ scopeImported s-  return $ s { scopePrivate = pri, scopePublic = pub, scopeImported = imp }+  nss <- sequence [ (,) nsid <$> mapNS nsid ns | (nsid, ns) <- scopeNameSpaces s ]+  return $ s { scopeNameSpaces = nss }   where     mapNS acc = mapNameSpaceM (fd acc) (fm acc)  -- | Same as 'mapScopeM' but applies the same function to both the public and --   private name spaces.-mapScopeM_ :: Monad m =>+mapScopeM_ :: (Functor m, Monad m) =>   (NamesInScope   -> m NamesInScope  ) ->   (ModulesInScope -> m ModulesInScope) ->   Scope -> m Scope@@ -289,12 +289,15 @@ 	    (NameSpaceId -> ModulesInScope -> ModulesInScope -> ModulesInScope) -> 	    Scope -> Scope -> Scope zipScope fd fm s1 s2 =-  s1 { scopePrivate  = zipNS PrivateNS  (scopePrivate  s1) (scopePrivate  s2)-     , scopePublic   = zipNS PublicNS   (scopePublic   s1) (scopePublic   s2)-     , scopeImported = zipNS ImportedNS (scopeImported s1) (scopeImported s2)+  s1 { scopeNameSpaces = [ (nsid, zipNS nsid ns1 ns2)+                         | ((nsid, ns1), (nsid', ns2)) <- zipWith' (,) (scopeNameSpaces s1) (scopeNameSpaces s2)+                         , assert (nsid == nsid')+                         ]      , scopeImports  = Map.union (scopeImports s1) (scopeImports s2)      }   where+    assert True  = True+    assert False = __IMPOSSIBLE__     zipNS acc = zipNameSpace (fd acc) (fm acc)  -- | Same as 'zipScope' but applies the same function to both the public and@@ -311,20 +314,25 @@  -- | Return all names in a scope. allNamesInScope :: InScope a => Scope -> ThingsInScope a-allNamesInScope = namesInScope [scopePublic, scopeImported, scopePrivate]+allNamesInScope = namesInScope [minBound..maxBound] +allNamesInScope' :: InScope a => Scope -> ThingsInScope (a, Access)+allNamesInScope' s =+  foldr1 mergeNames [ map (, nameSpaceAccess ns) <$> namesInScope [ns] s+                    | ns <- [minBound..maxBound] ]+ -- | Returns the scope's non-private names. exportedNamesInScope :: InScope a => Scope -> ThingsInScope a-exportedNamesInScope = namesInScope [scopePublic, scopeImported]+exportedNamesInScope = namesInScope [PublicNS, ImportedNS, OnlyQualifiedNS] -namesInScope :: InScope a => [Scope -> NameSpace] -> Scope -> ThingsInScope a-namesInScope fs s =-  foldr1 mergeNames [ inNameSpace (f s) | f <- fs ]+namesInScope :: InScope a => [NameSpaceId] -> Scope -> ThingsInScope a+namesInScope ids s =+  foldr1 mergeNames [ inNameSpace (scopeNameSpace nsid s) | nsid <- ids ]  allThingsInScope :: Scope -> NameSpace-allThingsInScope = thingsInScope [scopePublic, scopeImported, scopePrivate]+allThingsInScope = thingsInScope [minBound..maxBound] -thingsInScope :: [Scope -> NameSpace] -> Scope -> NameSpace+thingsInScope :: [NameSpaceId] -> Scope -> NameSpace thingsInScope fs s =   NameSpace { nsNames   = namesInScope fs s             , nsModules = namesInScope fs s@@ -345,15 +353,13 @@ -- | Move all names in a scope to the given name space (except never move from --   Imported to Public). setScopeAccess :: NameSpaceId -> Scope -> Scope-setScopeAccess a s = s { scopeImported = ns ImportedNS-		       , scopePrivate  = ns PrivateNS-                       , scopePublic   = ns PublicNS+setScopeAccess a s = s { scopeNameSpaces = [ (nsid, ns nsid) | (nsid, _) <- scopeNameSpaces s ] 		       }   where     zero  = emptyNameSpace     one   = allThingsInScope s-    imp   = thingsInScope [scopeImported] s-    noimp = thingsInScope [scopePublic, scopePrivate] s+    imp   = thingsInScope [ImportedNS] s+    noimp = thingsInScope [PublicNS, PrivateNS, OnlyQualifiedNS] s      ns b = case (a, b) of       (PublicNS, PublicNS)   -> noimp@@ -361,12 +367,17 @@       _ | a == b             -> one         | otherwise          -> zero +setNameSpace :: NameSpaceId -> NameSpace -> Scope -> Scope+setNameSpace nsid ns s =+  s { scopeNameSpaces = [ (nsid', if nsid == nsid' then ns else ns')+                        | (nsid', ns') <- scopeNameSpaces s ] }+ -- | Add names to a scope. addNamesToScope :: NameSpaceId -> C.Name -> [AbstractName] -> Scope -> Scope addNamesToScope acc x ys s = mergeScope s s1   where-    s1 = setScopeAccess acc $ emptyScope-	 { scopePublic = emptyNameSpace { nsNames = Map.singleton x ys } }+    s1 = setScopeAccess acc $ setNameSpace PublicNS ns emptyScope+    ns = emptyNameSpace { nsNames = Map.singleton x ys }  -- | Add a name to a scope. addNameToScope :: NameSpaceId -> C.Name -> AbstractName -> Scope -> Scope@@ -376,8 +387,8 @@ addModuleToScope :: NameSpaceId -> C.Name -> AbstractModule -> Scope -> Scope addModuleToScope acc x m s = mergeScope s s1   where-    s1 = setScopeAccess acc $ emptyScope-	 { scopePublic = emptyNameSpace { nsModules = Map.singleton x [m] } }+    s1 = setScopeAccess acc $ setNameSpace PublicNS ns emptyScope+    ns = emptyNameSpace { nsModules = Map.singleton x [m] }  -- | Apply an 'ImportDirective' to a scope. applyImportDirective :: ImportDirective -> Scope -> Scope@@ -431,8 +442,12 @@  -- | Restrict the private name space of a scope restrictPrivate :: Scope -> Scope-restrictPrivate s = s { scopePrivate = emptyNameSpace, scopeImports = Map.empty }+restrictPrivate s = setNameSpace PrivateNS emptyNameSpace $ s { scopeImports = Map.empty } +-- | Remove names that can only be used qualified (when opening a scope)+removeOnlyQualified :: Scope -> Scope+removeOnlyQualified s = setNameSpace OnlyQualifiedNS emptyNameSpace s+ -- | Get the public parts of the public modules of a scope publicModules :: ScopeInfo -> Map A.ModuleName Scope publicModules scope = Map.filterWithKey (\m _ -> reachable m) allMods@@ -460,8 +475,11 @@     current = this : parents  -- | Look up a name in the scope-scopeLookup :: forall a. InScope a => C.QName -> ScopeInfo -> [a]-scopeLookup q scope = nub $ findName q root ++ imports+scopeLookup :: InScope a => C.QName -> ScopeInfo -> [a]+scopeLookup q scope = map fst $ scopeLookup' q scope++scopeLookup' :: forall a. InScope a => C.QName -> ScopeInfo -> [(a, Access)]+scopeLookup' q scope = nubBy ((==) `on` fst) $ findName q root ++ imports   where     this    :: A.ModuleName     this    = scopeCurrent scope@@ -480,30 +498,29 @@       (m, r) <- splitName q       return (C.Qual x m, r) -    imported :: C.QName -> [A.ModuleName]-    imported q = maybe [] (:[]) $ Map.lookup q $ scopeImports root+    imported :: C.QName -> [(A.ModuleName, Access)]+    imported q = maybe [] ((:[]) . (, PublicAccess)) $ Map.lookup q $ scopeImports root -    topImports :: [a]+    topImports :: [(a, Access)]     topImports = case tag of       NameTag   -> []-      ModuleTag -> map AbsModule (imported q)+      ModuleTag -> map (AbsModule *** id) (imported q) -    imports :: [a]+    imports :: [(a, Access)]     imports = topImports ++ do       (m, x) <- splitName q-      m <- imported m-      x <- findName x (restrictPrivate $ moduleScope m)-      return x+      m <- fst <$> imported m+      findName x (restrictPrivate $ moduleScope m)      moduleScope :: A.ModuleName -> Scope     moduleScope name = case Map.lookup name (scopeModules scope) of       Nothing -> __IMPOSSIBLE__       Just s  -> s -    lookupName :: forall a. InScope a => C.Name -> Scope -> [a]-    lookupName x s = maybe [] id $ Map.lookup x (allNamesInScope s)+    lookupName :: forall a. InScope a => C.Name -> Scope -> [(a, Access)]+    lookupName x s = maybe [] id $ Map.lookup x (allNamesInScope' s) -    findName :: forall a. InScope a => C.QName -> Scope -> [a]+    findName :: forall a. InScope a => C.QName -> Scope -> [(a, Access)]     findName (C.QName x)  s = lookupName x s     findName (C.Qual x q) s = do         m <- nub $ mods ++ defs -- record types will appear bot as a mod and a def@@ -511,9 +528,9 @@         findName q (restrictPrivate s')       where         mods, defs :: [ModuleName]-        mods = amodName <$> lookupName x s+        mods = amodName . fst <$> lookupName x s         -- Qualified constructors are qualified by their datatype rather than a module-        defs = mnameFromList . qnameToList . anameName <$> lookupName x s+        defs = mnameFromList . qnameToList . anameName . fst <$> lookupName x s  -- * Inverse look-up

src/full/Agda/Syntax/Scope/Monad.hs view

@@ -128,15 +128,11 @@ modifyCurrentNameSpace :: NameSpaceId -> (NameSpace -> NameSpace) -> ScopeM () modifyCurrentNameSpace acc f = modifyCurrentScope action   where-    action s = s { scopePublic   = pub $ scopePublic  s-                 , scopePrivate  = pri $ scopePrivate s-                 , scopeImported = imp $ scopeImported s-                 }-    (pub, pri, imp) = case acc of-      PublicNS   -> (f, id, id)-      PrivateNS  -> (id, f, id)-      ImportedNS -> (id, id, f)+    action s = s { scopeNameSpaces = [ (nsid, f' nsid ns) | (nsid, ns) <- scopeNameSpaces s ] } +    f' a | a == acc  = f+         | otherwise = id+ setContextPrecedence :: Precedence -> ScopeM () setContextPrecedence p = modifyScopeInfo $ \s -> s { scopePrecedence = p } @@ -187,7 +183,7 @@ -- * Resolving names  data ResolvedName = VarName A.Name-                  | DefinedName AbstractName+                  | DefinedName Access AbstractName                   | ConstructorName [AbstractName]                   | UnknownName   deriving (Show)@@ -199,13 +195,13 @@   let vars = map (C.QName -*- id) $ scopeLocals scope   case lookup x vars of     Just y  -> return $ VarName $ y { nameConcrete = unqualify x }-    Nothing -> case scopeLookup x scope of+    Nothing -> case scopeLookup' x scope of       [] -> return UnknownName-      ds | all ((==ConName) . anameKind) ds ->+      ds | all ((==ConName) . anameKind . fst) ds ->         return $ ConstructorName-               $ map (\d -> updateConcreteName d $ unqualify x) ds-      [d] -> return $ DefinedName $ updateConcreteName d (unqualify x)-      ds  -> typeError $ AmbiguousName x (map anameName ds)+               $ map (\ (d, _) -> updateConcreteName d $ unqualify x) ds+      [(d, a)] -> return $ DefinedName a $ updateConcreteName d (unqualify x)+      ds  -> typeError $ AmbiguousName x (map (anameName . fst) ds)   where   updateConcreteName :: AbstractName -> C.Name -> AbstractName   updateConcreteName d@(AbsName { anameName = an@(A.QName { qnameName = qn }) }) x =@@ -226,7 +222,7 @@   r <- resolveName x   case r of     VarName y          -> return $ nameFixity y-    DefinedName d      -> return $ nameFixity $ qnameName $ anameName d+    DefinedName _ d    -> return $ nameFixity $ qnameName $ anameName d     ConstructorName ds       | null fs        -> __IMPOSSIBLE__       | allEqual fs    -> return $ head fs@@ -248,7 +244,7 @@ bindName acc kind x y = do   r  <- resolveName (C.QName x)   ys <- case r of-    DefinedName d      -> typeError $ ClashingDefinition (C.QName x) $ anameName d+    DefinedName _ d    -> typeError $ ClashingDefinition (C.QName x) $ anameName d     VarName z          -> typeError $ ClashingDefinition (C.QName x) $ A.qualify (mnameFromList []) z     ConstructorName [] -> __IMPOSSIBLE__     ConstructorName ds@@ -301,14 +297,16 @@     old  = scopeName s      copyM :: NameSpaceId -> ModulesInScope -> WSM ModulesInScope-    copyM ImportedNS ms = return ms-    copyM PrivateNS  _  = return Map.empty-    copyM PublicNS   ms = traverse (mapM $ onMod renMod) ms+    copyM ImportedNS      ms = return ms+    copyM PrivateNS       _  = return Map.empty+    copyM PublicNS        ms = traverse (mapM $ onMod renMod) ms+    copyM OnlyQualifiedNS ms = traverse (mapM $ onMod renMod) ms      copyD :: NameSpaceId -> NamesInScope -> WSM NamesInScope-    copyD ImportedNS ds = return ds-    copyD PrivateNS  _  = return Map.empty-    copyD PublicNS   ds = traverse (mapM $ onName renName) ds+    copyD ImportedNS      ds = return ds+    copyD PrivateNS       _  = return Map.empty+    copyD PublicNS        ds = traverse (mapM $ onName renName) ds+    copyD OnlyQualifiedNS ds = traverse (mapM $ onName renName) ds      onMod f m = do       x <- f $ amodName m@@ -404,7 +402,7 @@   m <- amodName <$> resolveModule cm   let ns = namespace current m   s <- setScopeAccess ns <$>-        (applyImportDirectiveM cm dir . restrictPrivate =<< getNamedScope m)+        (applyImportDirectiveM cm dir . removeOnlyQualified . restrictPrivate =<< getNamedScope m)   checkForClashes (scopeNameSpace ns s)   modifyCurrentScope (`mergeScope` s)   where

src/full/Agda/Syntax/Strict.hs view

@@ -19,16 +19,16 @@  instance Strict Term where     force t = case t of-	Var _ ts   -> force ts-	Def _ ts   -> force ts-	Con _ ts   -> force ts-	Lam _ t    -> force t-	Lit _	   -> 0-	Pi a b	   -> force (a,b)-	Fun a b    -> force (a,b)-	Sort s	   -> force s-	MetaV _ ts -> force ts-        DontCare   -> 0+	Var _ ts    -> force ts+	Def _ ts    -> force ts+	Con _ ts    -> force ts+	Lam _ t     -> force t+	Lit _	    -> 0+        Level l     -> force l+	Pi a b	    -> force (a,b)+	Sort s	    -> force s+	MetaV _ ts  -> force ts+        DontCare mt -> force mt  instance Strict Type where     force (El s t) = force (s,t)@@ -37,16 +37,26 @@     force s = case s of 	Type n     -> force n 	Prop       -> 0-	Lub s1 s2  -> force (s1,s2)-	Suc s      -> force s-	MetaS _ as -> force as         Inf        -> 0         DLub s1 s2 -> force (s1, s2) +instance Strict Level where+  force (Max as) = force as++instance Strict PlusLevel where+  force ClosedLevel{} = 0+  force (Plus _ l) = force l++instance Strict LevelAtom where+  force l = case l of+    MetaLevel _ vs   -> force vs+    NeutralLevel v   -> force v+    BlockedLevel _ v -> force v+    UnreducedLevel v -> force v+ instance Strict ClauseBody where     force (Body t)   = force t     force (Bind b)   = force b-    force (NoBind b) = force b     force  NoBody    = 0  instance Strict C.Expr where@@ -70,8 +80,11 @@ instance Strict a => Strict [a] where     force = sum . map force +instance Strict a => Strict (Maybe a) where+    force = maybe 0 force+ instance Strict a => Strict (Abs a) where-    force = force . absBody+    force = force . unAbs  instance Strict Token where   -- TODO: This is just a dummy instance. Why can't we just use the

src/full/Agda/Syntax/Translation/AbstractToConcrete.hs view

@@ -1,6 +1,5 @@ {-# LANGUAGE CPP, PatternGuards, MultiParamTypeClasses, FunctionalDependencies,-             TypeSynonymInstances, FlexibleInstances, UndecidableInstances,-             OverlappingInstances+             TypeSynonymInstances, FlexibleInstances, UndecidableInstances   #-}  {-| The translation of abstract syntax to concrete syntax has two purposes.@@ -19,7 +18,8 @@     , withScope     , makeEnv     , abstractToConcrete-    , AbsToCon, TypeAndDef, DontTouchMe, Env+    , AbsToCon, DontTouchMe, Env+    , noTakenNames     ) where  import Control.Applicative@@ -43,7 +43,7 @@ import Agda.Syntax.Scope.Base  import Agda.TypeChecking.Monad.State (getScope)-import Agda.TypeChecking.Monad.Base  (MonadTCM)+import Agda.TypeChecking.Monad.Base  (TCM)  import Agda.Utils.Maybe import Agda.Utils.Monad hiding (bracket)@@ -84,12 +84,15 @@ withScope :: ScopeInfo -> AbsToCon a -> AbsToCon a withScope scope = local $ \e -> e { currentScope = scope } +noTakenNames :: AbsToCon a -> AbsToCon a+noTakenNames = local $ \e -> e { takenNames = Set.empty }+ -- The Monad --------------------------------------------------------------  -- | We make the translation monadic for modularity purposes. type AbsToCon = Reader Env -runAbsToCon :: MonadTCM tcm => AbsToCon a -> tcm a+runAbsToCon :: AbsToCon a -> TCM a runAbsToCon m = do   scope <- getScope   return $ runReader m (makeEnv scope)@@ -97,7 +100,7 @@ abstractToConcrete :: ToConcrete a c => Env -> a -> c abstractToConcrete flags a = runReader (toConcrete a) flags -abstractToConcreteCtx :: (MonadTCM tcm, ToConcrete a c) => Precedence -> a -> tcm c+abstractToConcreteCtx :: ToConcrete a c => Precedence -> a -> TCM c abstractToConcreteCtx ctx x = do   scope <- getScope   let scope' = scope { scopePrecedence = ctx }@@ -105,7 +108,7 @@   where     scope = (currentScope defaultEnv) { scopePrecedence = ctx } -abstractToConcrete_ :: (MonadTCM tcm, ToConcrete a c) => a -> tcm c+abstractToConcrete_ :: ToConcrete a c => a -> TCM c abstractToConcrete_ x = do   scope <- getScope   return $ abstractToConcrete (makeEnv scope) x@@ -136,7 +139,9 @@     do  scope <- asks currentScope         case inverseScopeLookupName x scope of             Just y  -> return y-            Nothing -> return $ C.Qual (C.Name noRange [Id ""]) $ qnameToConcrete x+            Nothing+              | show (qnameToConcrete x) == "_" -> return $ qnameToConcrete x+              | otherwise -> return $ C.Qual (C.Name noRange [Id ""]) $ qnameToConcrete x                 -- this is what happens for names that are not in scope (private names)  lookupModule :: A.ModuleName -> AbsToCon C.QName@@ -166,7 +171,9 @@  -- | General bracketing function. bracket' ::    (e -> e)             -- ^ the bracketing function-            -> (Precedence -> Bool) -- ^ do we need brackets+            -> (Precedence -> Bool) -- ^ Should we bracket things+                                    --   which have the given+                                    --   precedence?             -> e -> AbsToCon e bracket' paren needParen e =     do  p <- currentPrecedence@@ -263,6 +270,7 @@  instance ToConcrete a c => ToConcrete (Arg a) (Arg c) where     toConcrete (Arg h@Hidden    r x) = Arg h r <$> toConcreteCtx TopCtx x+    toConcrete (Arg h@Instance  r x) = Arg h r <$> toConcreteCtx TopCtx x     toConcrete (Arg h@NotHidden r x) = Arg h r <$> toConcrete x      bindToConcrete (Arg h r x) ret = bindToConcreteCtx (hiddenArgumentCtx h) x $ ret . Arg h r@@ -327,14 +335,14 @@         bracket lamBrackets         $ case lamView e of             (bs, e) ->-                bindToConcrete bs $ \bs -> do+                bindToConcrete (map makeDomainFree bs) $ \bs -> do                     e  <- toConcreteCtx TopCtx e                     return $ C.Lam (getRange i) bs e         where-            lamView (A.Lam _ b@(A.DomainFree _ _) e) =+            lamView (A.Lam _ b@(A.DomainFree _ _ _) e) =                 case lamView e of                     ([], e)                        -> ([b], e)-                    (bs@(A.DomainFree _ _ : _), e) -> (b:bs, e)+                    (bs@(A.DomainFree _ _ _ : _), e) -> (b:bs, e)                     _                              -> ([b], e)             lamView (A.Lam _ b@(A.DomainFull _) e) =                 case lamView e of@@ -342,7 +350,14 @@                     (bs@(A.DomainFull _ : _), e)   -> (b:bs, e)                     _                              -> ([b], e)             lamView e = ([], e)-+    toConcrete (A.ExtendedLam i di qname cs) = do+          decls <- toConcrete cs+          let removeApp (C.RawAppP r (lam:es)) = C.RawAppP r es+              removeApp (C.AppP p np) = namedThing $ unArg np+              removeApp _ = __IMPOSSIBLE__+          let decl2clause (C.FunClause lhs rhs wh) = (lhs {lhsOriginalPattern = removeApp $ lhsOriginalPattern lhs},rhs,wh)+              decl2clause _ = __IMPOSSIBLE__+          return $ C.ExtendedLam (getRange i) (map decl2clause $ concat decls)     toConcrete (A.Pi _ [] e) = toConcrete e     toConcrete t@(A.Pi i _ _)  = case piTel t of       (tel, e) ->@@ -356,12 +371,14 @@      toConcrete (A.Fun i a b) =         bracket piBrackets-        $ do a' <- toConcreteCtx FunctionSpaceDomainCtx a+        $ do a' <- toConcreteCtx (if irr then DotPatternCtx else FunctionSpaceDomainCtx) a              b' <- toConcreteCtx TopCtx b              return $ C.Fun (getRange i) (addDot a' $ mkArg a') b'         where-            addDot a e = if (argRelevance a == Irrelevant) then Dot (getRange a) e else e+            irr        = argRelevance a == Irrelevant+            addDot a e = if irr then Dot (getRange a) e else e             mkArg (Arg Hidden    r e) = HiddenArg (getRange e) (unnamed e)+            mkArg (Arg Instance  r e) = InstanceArg (getRange e) (unnamed e)             mkArg (Arg NotHidden r e) = e      toConcrete (A.Set i 0)  = return $ C.Set (getRange i)@@ -380,6 +397,13 @@         es <- toConcreteCtx TopCtx es         return $ C.Rec (getRange i) $ zip xs es +    toConcrete (A.RecUpdate i e fs) =+      bracket appBrackets $ do+        let (xs, es) = unzip fs+        e <- toConcrete e+        es <- toConcreteCtx TopCtx es+        return $ C.RecUpdate (getRange i) e $ zip xs es+     toConcrete (A.ETel tel) = do       tel <- toConcrete tel       return $ C.ETel tel@@ -392,14 +416,31 @@             e' <- toConcrete e             return $ C.QuoteGoal (getRange i) x' e'     toConcrete (A.Quote i) = return $ C.Quote (getRange i)+    toConcrete (A.QuoteTerm i) = return $ C.QuoteTerm (getRange i)+    toConcrete (A.Unquote i) = return $ C.Unquote (getRange i) +    -- Andreas, 2010-10-05 print irrelevant things as ordinary things+    toConcrete (A.DontCare e) = toConcrete e+--    toConcrete (A.DontCare e) = C.DontCare <$> toConcreteCtx TopCtx e+{-     -- Andreas, 2010-09-21 abuse C.Underscore to print irrelevant things     toConcrete (A.DontCare) = return $ C.Underscore noRange Nothing+-} +makeDomainFree :: A.LamBinding -> A.LamBinding+makeDomainFree b@(A.DomainFull (A.TypedBindings r (Arg h rel (A.TBind _ [x] t)))) =+  case unScope t of+    A.Underscore MetaInfo{metaNumber = Nothing} -> A.DomainFree h rel x+    _ -> b+  where+    unScope (A.ScopedExpr _ e) = unScope e+    unScope e = e+makeDomainFree b = b+ -- Binder instances -------------------------------------------------------  instance ToConcrete A.LamBinding C.LamBinding where-    bindToConcrete (A.DomainFree h x) ret = bindToConcrete x $ ret . C.DomainFree h . mkBoundName_+    bindToConcrete (A.DomainFree h rel x) ret = bindToConcrete x $ ret . C.DomainFree h rel . mkBoundName_     bindToConcrete (A.DomainFull b)   ret = bindToConcrete b $ ret . C.DomainFull  instance ToConcrete A.TypedBindings C.TypedBindings where@@ -424,18 +465,15 @@                 , C.FunClause (C.LHS (C.IdentP $ C.QName x) [] [] [])                               e C.NoWhere                 ]-    bindToConcrete (LetApply i x tel y es _ _) ret = do+    bindToConcrete (LetApply i x modapp _ _) ret = do       x' <- unqualify <$> toConcrete x-      y' <- toConcrete y-      bindToConcrete tel $ \tel -> do-      es' <- toConcrete es-      let r = fuseRange y' es'+      modapp <- toConcrete modapp+      let r = getRange modapp           open = maybe DontOpen id $ minfoOpenShort i           dir  = maybe (ImportDirective r (Hiding []) [] False) id $ minfoDirective i       -- This is no use since toAbstract LetDefs is in localToAbstract.       local (openModule' x dir id) $-        ret [ C.ModuleMacro (getRange i) x' tel-                  (foldl (C.App r) (C.Ident y') es') open dir ]+        ret [ C.ModuleMacro (getRange i) x' modapp open dir ]     bindToConcrete (LetOpen i x) ret = do       x' <- toConcrete x       let dir = maybe defaultImportDir id $ minfoDirective i@@ -447,12 +485,21 @@ instance ToConcrete AsWhereDecls WhereClause where   bindToConcrete (AsWhereDecls []) ret = ret C.NoWhere   bindToConcrete (AsWhereDecls ds@[Section _ am _ _]) ret = do-    ds' <- toConcrete ds+    ds' <- declsToConcrete ds     cm  <- unqualify <$> lookupModule am     let wh' = (if isNoName cm then AnyWhere else SomeWhere cm) $ ds'     local (openModule' am defaultImportDir id) $ ret wh'-  bindToConcrete (AsWhereDecls ds) ret = ret . AnyWhere =<< toConcrete ds+  bindToConcrete (AsWhereDecls ds) ret =+    ret . AnyWhere =<< declsToConcrete ds +mergeSigAndDef :: [C.Declaration] -> [C.Declaration]+mergeSigAndDef (C.RecordSig _ x bs e : C.Record r y c _ Nothing fs : ds)+  | x == y = C.Record r y c bs (Just e) fs : mergeSigAndDef ds+mergeSigAndDef (C.DataSig _ _ x bs e : C.Data r i y _ Nothing cs : ds)+  | x == y = C.Data r i y bs (Just e) cs : mergeSigAndDef ds+mergeSigAndDef (d : ds) = d : mergeSigAndDef ds+mergeSigAndDef [] = []+ openModule' :: A.ModuleName -> ImportDirective -> (Scope -> Scope) -> Env -> Env openModule' x dir restrict env = env{currentScope = sInfo{scopeModules = mods'}}   where sInfo = currentScope env@@ -467,8 +514,8 @@  -- Declaration instances -------------------------------------------------- -instance ToConcrete [A.Declaration] [C.Declaration] where-    toConcrete ds = concat <$> mapM toConcrete ds+declsToConcrete :: [A.Declaration] -> AbsToCon [C.Declaration]+declsToConcrete ds = mergeSigAndDef . concat <$> toConcrete ds  instance ToConcrete A.RHS (C.RHS, [C.Expr], [C.Expr], [C.Declaration]) where     toConcrete (A.RHS e) = do@@ -477,64 +524,32 @@     toConcrete A.AbsurdRHS = return (C.AbsurdRHS, [], [], [])     toConcrete (A.WithRHS _ es cs) = do       es <- toConcrete es-      cs <- toConcrete cs-      return (C.AbsurdRHS, [], es, concat cs)+      cs <- concat <$> toConcrete cs+      return (C.AbsurdRHS, [], es, cs)     toConcrete (A.RewriteRHS _ eqs rhs wh) = do-      wh <- toConcrete wh+      wh <- declsToConcrete wh       (rhs, eqs', es, whs) <- toConcrete rhs       unless (null eqs')         __IMPOSSIBLE__       eqs <- toConcrete eqs       return (rhs, eqs, es, wh ++ whs) -data TypeAndDef = TypeAndDef A.TypeSignature A.Definition--instance ToConcrete TypeAndDef [C.Declaration] where-  -- We don't do withInfixDecl here. It's done at the declaration level.--  toConcrete (TypeAndDef (ScopedDecl scope [d]) def) =-    withScope scope $ toConcrete (TypeAndDef d def)--  toConcrete (TypeAndDef d (ScopedDef scope def)) =-    withScope scope $ toConcrete (TypeAndDef d def)--  toConcrete (TypeAndDef (Axiom _ rel x t) (FunDef i _ cs)) =-    withAbstractPrivate i $ do-    t'  <- toConcreteCtx TopCtx t-    cs' <- toConcrete cs-    x'  <- unsafeQNameToName <$> toConcrete x-    return $ TypeSig rel x' t' : concat cs'--  toConcrete (TypeAndDef (Axiom _ _ x t) (DataDef i _ bs cs)) =-    withAbstractPrivate i $-    bindToConcrete tel $ \tel' -> do-      t'       <- toConcreteCtx TopCtx t0-      (x',cs') <- (unsafeQNameToName -*- id) <$> toConcrete (x, map Constr cs)-      return [ C.Data (getRange i) Inductive x' tel' t' cs' ]-    where-      (tel, t0) = mkTel (length bs) t-      mkTel n (ScopedExpr _ t) = mkTel n t-      mkTel 0 t            = ([], t)-      mkTel n (A.Pi _ b t) = (b++) -*- id $ mkTel (n - 1) t-      mkTel _ _            = __IMPOSSIBLE__---      mkTel n t            = error $ "mkTel " ++ show n ++ " " ++ show t+instance ToConcrete (Maybe A.QName) (Maybe C.Name) where+  toConcrete Nothing = return Nothing+  toConcrete (Just x) = do+    x' <- toConcrete (qnameName x)+    return $ Just x' -  toConcrete (TypeAndDef (Axiom _ _ x t) (RecDef  i _ c bs _ cs)) =-    withAbstractPrivate i $-    bindToConcrete tel $ \tel' -> do-      t'       <- toConcreteCtx TopCtx t0-      (x',cs') <- (unsafeQNameToName -*- id) <$> toConcrete (x, map Constr cs)-      c'       <- Trav.mapM (\d -> unsafeQNameToName <$>-                                     toConcrete (axiomName d)) c-      return [ C.Record (getRange i) x' c' tel' t' cs' ]-    where-      (tel, t0) = mkTel (length bs) t-      mkTel n (A.ScopedExpr _ t) = mkTel n t-      mkTel 0 t                  = ([], t)-      mkTel n (A.Pi _ b t)       = (b++) -*- id $ mkTel (n - 1) t-      mkTel _ _                  = __IMPOSSIBLE__+-- | Helper function used in instance @ToConcrete Definition@.+telToTypedBindingss :: [C.LamBinding] -> [C.TypedBindings]+telToTypedBindingss = map lamBindingToTypedBindings where -  toConcrete _ = __IMPOSSIBLE__+  lamBindingToTypedBindings :: C.LamBinding -> C.TypedBindings+  lamBindingToTypedBindings b =+    case b of+      C.DomainFull t     -> t+      C.DomainFree h r n -> C.TypedBindings noRange $+        Arg h r $ C.TBind noRange [n] $ C.Underscore noRange Nothing  instance ToConcrete (Constr A.Constructor) C.Declaration where   toConcrete (Constr (A.ScopedDecl scope [d])) =@@ -558,9 +573,20 @@           -- no code for it, but GHC 7's completeness checker spotted           -- that the case was not covered. +instance ToConcrete A.ModuleApplication C.ModuleApplication where+  toConcrete (A.SectionApp tel y es) = do+    y  <- toConcrete y+    bindToConcrete tel $ \tel -> do+    es <- toConcrete es+    let r = fuseRange y es+    return $ C.SectionApp r tel (foldl (C.App r) (C.Ident y) es)+  toConcrete (A.RecordModuleIFS rec) = do+    rec <- toConcrete rec+    return $ C.RecordModuleIFS (getRange rec) rec+ instance ToConcrete A.Declaration [C.Declaration] where   toConcrete (ScopedDecl scope ds) =-    withScope scope $ toConcrete ds+    withScope scope (declsToConcrete ds)    toConcrete (Axiom i rel x t) = do     x' <- unsafeQNameToName <$> toConcrete x@@ -584,39 +610,50 @@       return [C.Primitive (getRange i) [C.TypeSig Relevant x' t']]         -- Primitives are always relevant. -  toConcrete (Definition i ts ds) = do-      ixs' <- map (id -*- unsafeQNameToName) <$> toConcrete (map (DontTouchMe -*- id) ixs)-      withInfixDecls ixs' $ do-        ds' <- concat <$> toConcrete (zipWith TypeAndDef ts ds)-        return [mutual (getRange i) ds']-      where-          ixs = map getInfoAndName ts-          is  = map fst ixs-          getInfoAndName (A.Axiom i _ x _)        = (i,x)-          getInfoAndName (A.ScopedDecl scope [d]) = getInfoAndName d-          getInfoAndName _                        = __IMPOSSIBLE__+  toConcrete (A.FunDef i _ cs) =+    withAbstractPrivate i $ concat <$> toConcrete cs -          mutual r [d] = d-          mutual r ds  = C.Mutual r ds+  toConcrete (A.DataSig i x bs t) =+    withAbstractPrivate i $+    bindToConcrete bs $ \tel' -> do+      x' <- unsafeQNameToName <$> toConcrete x+      t' <- toConcreteCtx TopCtx t+      return [ C.DataSig (getRange i) Inductive x' (map C.DomainFull tel') t' ] +  toConcrete (A.DataDef i x bs cs) =+    withAbstractPrivate i $+    bindToConcrete (map makeDomainFree bs) $ \tel' -> do+      (x',cs') <- (unsafeQNameToName -*- id) <$> toConcrete (x, map Constr cs)+      return [ C.Data (getRange i) Inductive x' tel' Nothing cs' ]++  toConcrete (A.RecSig i x bs t) =+    withAbstractPrivate i $+    bindToConcrete bs $ \tel' -> do+      x' <- unsafeQNameToName <$> toConcrete x+      t' <- toConcreteCtx TopCtx t+      return [ C.RecordSig (getRange i) x' (map C.DomainFull tel') t' ]++  toConcrete (A.RecDef  i x c bs t cs) =+    withAbstractPrivate i $+    bindToConcrete (map makeDomainFree bs) $ \tel' -> do+      (x',cs') <- (unsafeQNameToName -*- id) <$> toConcrete (x, map Constr cs)+      return [ C.Record (getRange i) x' Nothing tel' Nothing cs' ]++  toConcrete (A.Mutual i ds) = declsToConcrete ds+   toConcrete (A.Section i x tel ds) = do     x <- toConcrete x     bindToConcrete tel $ \tel -> do-    ds <- toConcrete ds+    ds <- declsToConcrete ds     return [ C.Module (getRange i) x tel ds ] -  toConcrete (A.Apply i x tel y es _ _) = do+  toConcrete (A.Apply i x modapp _ _) = do     x  <- unsafeQNameToName <$> toConcrete x-    y  <- toConcrete y-    bindToConcrete tel $ \tel -> do-    es <- toConcrete es-    let r = fuseRange y es+    modapp <- toConcrete modapp+    let r = getRange modapp         open = maybe DontOpen id $ minfoOpenShort i         dir  = maybe (ImportDirective r (Hiding []) [] False) id $ minfoDirective i-    return [ C.ModuleMacro (getRange i) x tel-                (foldl (C.App r) (C.Ident y) es) open-                                                 dir-           ]+    return [ C.ModuleMacro (getRange i) x modapp open dir ]    toConcrete (A.Import i x) = do     x <- toConcrete x@@ -652,6 +689,12 @@         A.CompiledEpicPragma x e -> do           x <- toConcrete x           return $ C.CompiledEpicPragma r x e+        A.CompiledJSPragma x e -> do+          x <- toConcrete x+          return $ C.CompiledJSPragma r x e+        A.StaticPragma x -> do+            x <- toConcrete x+            return $ C.StaticPragma r x         A.EtaPragma x -> C.EtaPragma r <$> toConcrete x  -- Left hand sides --------------------------------------------------------@@ -706,17 +749,19 @@  data Hd = HdVar A.Name | HdCon A.QName | HdDef A.QName +cOpApp :: Range -> C.Name -> [C.Expr] -> C.Expr+cOpApp r n es = C.OpApp r n (map Ordinary es)+ tryToRecoverOpApp :: A.Expr -> AbsToCon C.Expr -> AbsToCon C.Expr-tryToRecoverOpApp e def = recoverOpApp bracket C.OpApp view e def+tryToRecoverOpApp e def = recoverOpApp bracket cOpApp view e def   where     view e = case AV.appView e of-      NonApplication _   -> Nothing-      Application h args -> Just (mkHd h, args)--    mkHd (HeadVar x)     = HdVar x-    mkHd (HeadCon (c:_)) = HdCon c-    mkHd (HeadCon [])    = __IMPOSSIBLE__-    mkHd (HeadDef f)     = HdDef f+      --NonApplication _   -> Nothing+      Application (Var x) args -> Just (HdVar x, args)+      Application (Def f) args -> Just (HdDef f, args)+      Application (Con (AmbQ (c:_))) args -> Just (HdCon c, args)+      Application (Con (AmbQ [])) args -> __IMPOSSIBLE__+      _ -> Nothing  tryToRecoverOpAppP :: A.Pattern -> AbsToCon C.Pattern -> AbsToCon C.Pattern tryToRecoverOpAppP p def = recoverOpApp bracketP_ C.OpAppP view p def

src/full/Agda/Syntax/Translation/ConcreteToAbstract.hs view

@@ -39,6 +39,7 @@ import Agda.Syntax.Concrete.Definitions as C import Agda.Syntax.Concrete.Operators import Agda.Syntax.Concrete.Pretty+import Agda.Syntax.Abstract.Pretty import Agda.Syntax.Fixity import Agda.Syntax.Notation import Agda.Syntax.Scope.Base@@ -46,7 +47,7 @@ import Agda.Syntax.Strict  import Agda.TypeChecking.Monad.Base (TypeError(..), Call(..), typeError,-                                     TCErr(..), TCErr'(..))+                                     TCErr(..), TCErr'(..), extendlambdaname) import Agda.TypeChecking.Monad.Trace (traceCall, traceCallCPS, setCurrentRange) import Agda.TypeChecking.Monad.State import Agda.TypeChecking.Monad.Options@@ -72,12 +73,13 @@ notAnExpression e           = typeError $ NotAnExpression e notAValidLetBinding d       = typeError $ NotAValidLetBinding d nothingAppliedToHiddenArg e = typeError $ NothingAppliedToHiddenArg e+nothingAppliedToInstanceArg e = typeError $ NothingAppliedToInstanceArg e  -- Debugging  printLocals :: Int -> String -> ScopeM () printLocals v s = verboseS "scope.top" v $ do-  locals <- scopeLocals <$> getScope+  locals <- getLocalVars   reportSLn "" 0 $ s ++ " " ++ show locals  printScope :: String -> Int -> String -> ScopeM ()@@ -112,12 +114,6 @@   s  <- getScope   return $ ScopedDecl s ds -annotateDefn :: ScopeM A.Definition -> ScopeM A.Definition-annotateDefn m = do-  d <- m-  s <- getScope-  return $ ScopedDef s d- annotateExpr :: ScopeM A.Expr -> ScopeM A.Expr annotateExpr m = do   e <- m@@ -158,19 +154,48 @@     notField _           = True      build (NiceField r f _ _ x (Arg h rel e) : fs) =-        C.Pi [C.TypedBindings r $ Arg h rel [C.TBind r [BName x f] e]] $ build fs+        C.Pi [C.TypedBindings r $ Arg h rel (C.TBind r [BName x f] e)] $ build fs       where r = getRange x     build (d : fs)                     = C.Let noRange (notSoNiceDeclarations [d]) $ build fs     build []                           = C.SetN noRange 0 -- todo: nicer -checkModuleMacro apply r p x tel m args open dir = withLocalVars $ do-    notPublicWithoutOpen open dir+checkModuleApplication (C.SectionApp _ tel e) m0 x dir' =+  withCurrentModule m0 $ do+    (m, args) <- case appView e of+      AppView (Ident m) args -> return (m, args)+      _                      -> notAModuleExpr e      tel' <- toAbstract tel-    (m0,m1,args') <- toAbstract ( NewModuleName x-                                , OldModuleName m-                                , args-                                )+    (m1,args') <- toAbstract (OldModuleName m+                             , args+                             )+    s  <- getNamedScope m1+    -- Drop constructors (OnlyQualified) if there are arguments. The record constructor+    -- isn't properly in the record module, so copying it will lead to badness.+    let noRecConstr | null args = id+                    | otherwise = removeOnlyQualified+    (s', (renM, renD)) <- copyScope m0 . noRecConstr =<< getNamedScope m1+    s' <- applyImportDirectiveM (C.QName x) dir' s'+    modifyCurrentScope $ const s'+    printScope "mod.inst" 20 "copied source module"+    reportSLn "scope.mod.inst" 30 $ "renamings:\n  " ++ show renD ++ "\n  " ++ show renM+    return ((A.SectionApp tel' m1 args'), renD, renM)+checkModuleApplication (C.RecordModuleIFS _ rec) m0 x dir' =+  withCurrentModule m0 $ do+    m1 <- toAbstract $ OldModuleName rec+    s <- getNamedScope m1+    (s', (renM, renD)) <- copyScope m0 s+    s' <- applyImportDirectiveM rec dir' s'+    modifyCurrentScope $ const s'++    printScope "mod.inst" 20 "copied record module"+    return ((A.RecordModuleIFS m1), renD, renM)++checkModuleMacro apply r p x modapp open dir = withLocalVars $ do+    notPublicWithoutOpen open dir++    m0 <- toAbstract (NewModuleName x)+     printScope "mod.inst" 20 "module macro"      -- If we're opening, the import directive is applied to the open,@@ -179,14 +204,7 @@                 DontOpen  -> dir                 DoOpen    -> defaultImportDir -    (renD, renM) <- withCurrentModule m0 $ do-      s  <- getNamedScope m1-      (s', (renM, renD)) <- copyScope m0 =<< getNamedScope m1-      s' <- applyImportDirectiveM (C.QName x) dir' s'-      modifyCurrentScope $ const s'-      printScope "mod.inst" 20 "copied source module"-      reportSLn "scope.mod.inst" 30 $ "renamings:\n  " ++ show renD ++ "\n  " ++ show renM-      return (renD, renM)+    (modapp', renD, renM) <- checkModuleApplication modapp m0 x dir'     bindModule p x m0     printScope "mod.inst.copy.after" 20 "after copying"     case open of@@ -195,7 +213,7 @@     printScope "mod.inst" 20 $ show open     stripNoNames     printScope "mod.inst" 10 $ "after stripping"-    return [ apply info (m0 `withRangesOf` [x]) tel' m1 args' renD renM ]+    return [ apply info (m0 `withRangesOf` [x]) modapp' renD renM ]   where     info = ModuleInfo              { minfoRange  = r@@ -309,7 +327,7 @@     reportSLn "scope.name" 10 $ "resolved " ++ show x ++ ": " ++ show qx     case qx of       VarName x'         -> return $ A.Var x'-      DefinedName d      -> return $ nameExpr d+      DefinedName _ d    -> return $ nameExpr d       ConstructorName ds -> return $ A.Con $ AmbQ (map anameName ds)       UnknownName        -> notInScope x @@ -322,11 +340,11 @@     rx <- resolveName x     z  <- case (rx, x) of       -- TODO: warn about shadowing-      (VarName y,     C.QName x)                          -> return $ Left x -- typeError $ RepeatedVariableInPattern y x-      (DefinedName d, C.QName x) | DefName == anameKind d -> return $ Left x-      (UnknownName,   C.QName x)                          -> return $ Left x-      (ConstructorName ds, _)                             -> return $ Right ds-      _                                                   ->+      (VarName y,       C.QName x)                          -> return $ Left x -- typeError $ RepeatedVariableInPattern y x+      (DefinedName _ d, C.QName x) | DefName == anameKind d -> return $ Left x+      (UnknownName,     C.QName x)                          -> return $ Left x+      (ConstructorName ds, _)                               -> return $ Right ds+      _                                                     ->         typeError $ GenericError $           "Cannot pattern match on " ++ show x ++ ", because it is not a constructor"     case z of@@ -344,8 +362,8 @@   toAbstract (OldName x) = do     rx <- resolveName (C.QName x)     case rx of-      DefinedName d -> return $ anameName d-      _             -> __IMPOSSIBLE__+      DefinedName _ d -> return $ anameName d+      _               -> error $ show x ++ " - " ++ show rx  newtype NewModuleName      = NewModuleName      C.Name newtype NewModuleQName     = NewModuleQName     C.QName@@ -389,11 +407,13 @@ -- | Peel off 'C.HiddenArg' and represent it as an 'NamedArg'. mkNamedArg :: C.Expr -> NamedArg C.Expr mkNamedArg (C.HiddenArg _ e) = Arg Hidden    Relevant e+mkNamedArg (C.InstanceArg _ e) = Arg Instance    Relevant e mkNamedArg e                 = Arg NotHidden Relevant $ unnamed e  -- | Peel off 'C.HiddenArg' and represent it as an 'Arg', throwing away any name. mkArg' :: Relevance -> C.Expr -> Arg C.Expr mkArg' r (C.HiddenArg _ e) = Arg Hidden    r $ namedThing e+mkArg' r (C.InstanceArg _ e) = Arg Instance    r $ namedThing e mkArg' r e                 = Arg NotHidden r e  -- | By default, arguments are @Relevant@.@@ -422,6 +442,23 @@         e <- toAbstractCtx prec e         return (e, False) +toAbstractOpArg :: Precedence -> OpApp C.Expr -> ScopeM A.Expr+toAbstractOpArg ctx (Ordinary e) = toAbstractCtx ctx e+toAbstractOpArg ctx (SyntaxBindingLambda r bs e) = toAbstractLam r bs e ctx++toAbstractLam :: Range -> [C.LamBinding] -> C.Expr -> Precedence -> ScopeM A.Expr+toAbstractLam r bs e ctx = do+        localToAbstract (map makeDomainFull bs) $ \bs ->+          case bs of+            b:bs' -> do+              e        <- toAbstractCtx ctx e+              let info = ExprRange r+              return $ A.Lam info b $ foldr mkLam e bs'+              where+                  mkLam b e = A.Lam (ExprRange $ fuseRange b e) b e+            [] -> __IMPOSSIBLE__++ instance ToAbstract C.Expr A.Expr where   toAbstract e =     traceCall (ScopeCheckExpr e) $ annotateExpr $ case e of@@ -480,21 +517,43 @@    -- Malplaced hidden argument       C.HiddenArg _ _ -> nothingAppliedToHiddenArg e+      C.InstanceArg _ _ -> nothingAppliedToInstanceArg e    -- Lambda       C.AbsurdLam r h -> return $ A.AbsurdLam (ExprRange r) h -      e0@(C.Lam r bs e) -> do-        localToAbstract bs $ \bs ->-          case bs of-            b:bs' -> do-              e        <- toAbstractCtx TopCtx e-              let info = ExprRange r-              return $ A.Lam info b $ foldr mkLam e bs'-              where-                  mkLam b e = A.Lam (ExprRange $ fuseRange b e) b e-            [] -> __IMPOSSIBLE__+      C.Lam r bs e -> toAbstractLam r bs e TopCtx +  -- Extended Lambda+      C.ExtendedLam r cs -> do+--        m <- getCurrentModule+        cname <- nextlamname r 0 extendlambdaname+        name  <- freshAbstractName_ cname+        reportSLn "toabstract.extendlambda" 10 $ "new extended lambda name: " ++ show name+        qname <- qualifyName_ name+        bindName PrivateAccess DefName cname qname+        let insertApp (C.RawAppP r es) = C.RawAppP r ((IdentP (C.QName cname)) : es)+            insertApp (C.IdentP q) = C.RawAppP (getRange q) ((IdentP (C.QName cname)) : [C.IdentP q])+            insertApp _ = __IMPOSSIBLE__+            insertHead (C.LHS p wps eqs with) = C.LHS (insertApp p) wps eqs with+            insertHead (C.Ellipsis r wps eqs with) = C.Ellipsis r wps eqs with+        scdef <- toAbstract (C.FunDef r [] defaultFixity' ConcreteDef cname+                               (map (\(lhs,rhs,wh) -> -- wh = NoWhere, see parser for more info+                                      C.Clause cname (insertHead lhs) rhs wh []) cs))+        case scdef of+          (A.ScopedDecl si [A.FunDef di qname' cs]) -> do+            setScope si+            return $ A.ExtendedLam (ExprRange r) di qname' cs+          _ -> __IMPOSSIBLE__+          where+            nextlamname :: Range -> Int -> String -> ScopeM C.Name+            nextlamname r i s = do+              let cname_pre = C.Name r [Id $ s ++ show i]+              rn <- resolveName (C.QName cname_pre)+              case rn of+                UnknownName -> return $ cname_pre+                _           -> nextlamname r (i+1) s+ -- Irrelevant non-dependent function type        C.Fun r e1 e2 -> do@@ -538,6 +597,13 @@         es <- toAbstractCtx TopCtx es         return $ A.Rec (ExprRange r) $ zip xs es +  -- Record update+      C.RecUpdate r e fs -> do+        let (xs, es) = unzip fs+        e <- toAbstract e+        es <- toAbstractCtx TopCtx es+        return $ A.RecUpdate (ExprRange r) e $ zip xs es+   -- Parenthesis       C.Paren _ e -> toAbstractCtx TopCtx e @@ -555,11 +621,21 @@         e' <- toAbstract e         return $ A.QuoteGoal (ExprRange $ getRange e) x' e'       C.Quote r -> return $ A.Quote (ExprRange r)+      C.QuoteTerm r -> return $ A.QuoteTerm (ExprRange r)+      C.Unquote r -> return $ A.Unquote (ExprRange r) +  -- DontCare+      C.DontCare e -> A.DontCare <$> toAbstract e+ instance ToAbstract C.LamBinding A.LamBinding where-  toAbstract (C.DomainFree h x) = A.DomainFree h <$> toAbstract (NewName x)-  toAbstract (C.DomainFull tb)  = A.DomainFull <$> toAbstract tb+  toAbstract (C.DomainFree h rel x) = A.DomainFree h rel <$> toAbstract (NewName x)+  toAbstract (C.DomainFull tb)      = A.DomainFull <$> toAbstract tb +makeDomainFull :: C.LamBinding -> C.LamBinding+makeDomainFull b@C.DomainFull{} = b+makeDomainFull (C.DomainFree h rel x) =+  C.DomainFull $ C.TypedBindings r $ Arg h rel $ C.TBind r [x] $ C.Underscore r Nothing+  where r = getRange x instance ToAbstract C.TypedBindings A.TypedBindings where   toAbstract (C.TypedBindings r bs) = A.TypedBindings r <$> toAbstract bs @@ -581,12 +657,12 @@     -- pushScope m     -- qm <- getCurrentModule     printScope "module" 20 $ "inside module " ++ show x-    ds <- withLocalVars $ do-            tel <- toAbstract tel-            (:[]) . A.Section info (qm `withRangesOfQ` x) tel <$>-              toAbstract ds-    scope <- getScope-    return (scope, ds)+    withLocalVars $ do+      tel   <- toAbstract tel+      ds    <- (:[]) . A.Section info (qm `withRangesOfQ` x) tel <$>+                 toAbstract ds+      scope <- getScope+      return (scope, ds)    -- Binding is done by the caller   printScope "module" 20 $ "after module " ++ show x@@ -619,7 +695,7 @@           return $ TopLevelInfo (ds' ++ ds) scope scope0         _ -> __IMPOSSIBLE__ -+-- | runs Syntax.Concrete.Definitions.niceDeclarations on main module niceDecls :: [C.Declaration] -> ScopeM [NiceDeclaration] niceDecls ds = case runNice $ niceDeclarations ds of   Left e   -> throwError $ TCErr Nothing $ Exception (getRange e) (show e)@@ -632,17 +708,19 @@ newtype LetDef = LetDef NiceDeclaration  instance ToAbstract LetDefs [A.LetBinding] where-    toAbstract (LetDefs ds) =-        concat <$> (toAbstract =<< map LetDef <$> niceDecls ds)+  toAbstract (LetDefs ds) =+    concat <$> (toAbstract =<< map LetDef <$> niceDecls ds)  instance ToAbstract LetDef [A.LetBinding] where     toAbstract (LetDef d) =         case d of-            NiceDef _ c [C.Axiom _ _ _ _ rel x t] [C.FunDef _ _ _ _ _ _ [cl]] ->-                do  e <- letToAbstract cl+            NiceMutual _ d@[C.FunSig _ fx _ rel x t, C.FunDef _ _ _ abstract _ [cl]] ->+                do  when (abstract == AbstractDef) $ do+                      typeError $ GenericError $ "abstract not allowed in let expressions"+                    e <- letToAbstract cl                     t <- toAbstract t-                    x <- toAbstract (NewName x)-                    return [ A.LetBind (LetRange $ getRange c) rel x t e ]+                    x <- toAbstract (NewName $ C.BName x fx)+                    return [ A.LetBind (LetRange $ getRange d) rel x t e ]              -- You can't open public in a let             NiceOpen r x dirs | not (C.publicOpen dirs) -> do@@ -659,9 +737,8 @@                                 m                      ] -            NiceModuleMacro r p a x tel e open dir | not (C.publicOpen dir) -> case appView e of-              AppView (Ident m) args -> checkModuleMacro LetApply r p x tel m args open dir-              _                      -> notAModuleExpr e+            NiceModuleMacro r p a x modapp open dir | not (C.publicOpen dir) ->+              checkModuleMacro LetApply r p x modapp open dir              _   -> notAValidLetBinding d         where@@ -673,83 +750,16 @@             letToAbstract _ = notAValidLetBinding d              -- Named patterns not allowed in let definitions-            lambda e (Arg h r (Named Nothing (A.VarP x))) = return $ A.Lam i (A.DomainFree h x) e+            lambda e (Arg h rel (Named Nothing (A.VarP x))) = return $ A.Lam i (A.DomainFree h rel x) e                 where                     i = ExprRange (fuseRange x e)-            lambda e (Arg h r (Named Nothing (A.WildP i))) =+            lambda e (Arg h rel (Named Nothing (A.WildP i))) =                 do  x <- freshNoName (getRange i)-                    return $ A.Lam i' (A.DomainFree h x) e+                    return $ A.Lam i' (A.DomainFree h rel x) e                 where                     i' = ExprRange (fuseRange i e)             lambda _ _ = notAValidLetBinding d --- instance ToAbstract C.Pragma [A.Pragma]--- moved higher up to reduce the probability of line number change--- in C.ImpossiblePragma  (test/fail/Impossible.agda)---- Only constructor names are bound by definitions.-instance ToAbstract NiceDefinition Definition where--    toAbstract d = annotateDefn $ case d of--    -- Function definitions-      C.FunDef r ds f p a x cs ->-        traceCall (ScopeCheckDefinition d) $ do-          (x',cs') <- toAbstract (OldName x,cs)-          return $ A.FunDef (mkDefInfo x f p a r) x' cs'--    -- Data definitions-      C.DataDef r f p a x pars cons ->-        traceCall (ScopeCheckDefinition d) $-        withLocalVars $ do--          -- Check for duplicate constructors-          do let cs   = map conName cons-                 dups = nub $ cs \\ nub cs-                 bad  = filter (`elem` dups) cs-             unless (distinct cs) $-               setCurrentRange (getRange bad) $-                  typeError $ DuplicateConstructors dups--          pars <- toAbstract pars-          x'   <- toAbstract (OldName x)-          -- Create the module for the qualified constructors-          checkForModuleClash x -- disallow shadowing previously defined modules-          let m = mnameFromList $ qnameToList x'-          createModule m-          bindModule p x m  -- make it a proper module-          cons <- toAbstract (map (ConstrDecl m) cons)-          -- Open the module-          -- openModule_ (C.QName x) defaultImportDir{ publicOpen = True }-          printScope "data" 20 $ "Checked data " ++ show x-          return $ A.DataDef (mkDefInfo x f p a r) x' pars cons-        where-          conName (C.Axiom _ _ _ _ _ c _) = c-          conName _ = __IMPOSSIBLE__--    -- Record definitions (mucho interesting)-      C.RecDef r f p a x c pars fields ->-        traceCall (ScopeCheckDefinition d) $-        withLocalVars $ do-          -- Check that the generated module doesn't clash with a previously-          -- defined module-          checkForModuleClash x-          pars   <- toAbstract pars-          x'     <- toAbstract (OldName x)-          contel <- toAbstract $ recordConstructorType fields-          m0     <- getCurrentModule-          let m = A.qualifyM m0 $ mnameFromList $ (:[]) $ last $ qnameToList x'-          printScope "rec" 15 "before record"-          createModule m-          afields <- withCurrentModule m $ do-            afields <- toAbstract fields-            printScope "rec" 15 "checked fields"-            return afields-          bindModule p x m-          c' <- mapM (toAbstract . ConstrDecl m) c-          printScope "rec" 15 "record complete"-          return $ A.RecDef (mkDefInfo x f p a r) x' c' pars contel afields- -- The only reason why we return a list is that open declarations disappears. -- For every other declaration we get a singleton list. instance ToAbstract NiceDeclaration A.Declaration where@@ -759,11 +769,13 @@     case d of    -- Axiom-    C.Axiom r f p a rel x t -> do+    C.Axiom r f p rel x t -> do+      clo <- commandLineOptions+      when (optSafe clo) (typeError (SafeFlagPostulate x))       t' <- toAbstractCtx TopCtx t       y  <- freshAbstractQName f x       bindName p DefName x y-      return [ A.Axiom (mkDefInfo x f p a r) rel y t' ]+      return [ A.Axiom (mkDefInfo x f p ConcreteDef r) rel y t' ]    -- Fields     C.NiceField r f p a x t -> do@@ -785,13 +797,93 @@       return [ A.Primitive (mkDefInfo x f p a r) y t' ]    -- Definitions (possibly mutual)-    NiceDef r cs ts ds -> do-      (ts', ds') <- toAbstract (ts, ds)-      return [ Definition (DeclInfo C.noName_ r) ts' ds' ]+    NiceMutual r ds -> do+      ds' <- toAbstract ds+      return [ A.Mutual (DeclInfo C.noName_ r) ds' ]                           -- TODO: what does the info mean here? -  -- TODO: what does an abstract module mean? The syntax doesn't allow it.-    NiceModule r p a (C.QName name) tel ds -> do+    C.NiceRecSig r f a x ls t -> withLocalVars $ do+        let toTypeBinding :: C.LamBinding -> C.TypedBindings+            toTypeBinding b = case makeDomainFull b of+               C.DomainFull b -> b+               _            -> __IMPOSSIBLE__+        ls' <- toAbstract (map toTypeBinding ls)+        x'  <- freshAbstractQName f x+        bindName a DefName x x'+        t' <- toAbstract t+        return [ A.RecSig (mkDefInfo x f a ConcreteDef r) x' ls' t' ]+    C.NiceDataSig r f a x ls t -> withLocalVars $ do+        printScope "scope.data.sig" 20 ("checking DataSig for " ++ show x)+        let toTypeBinding :: C.LamBinding -> C.TypedBindings+            toTypeBinding b = case makeDomainFull b of+               C.DomainFull b -> b+               _            -> __IMPOSSIBLE__+        ls' <- toAbstract (map toTypeBinding ls)+        x'  <- freshAbstractQName f x+        bindName a DefName x x'+        t' <- toAbstract t+        return [ A.DataSig (mkDefInfo x f a ConcreteDef r) x' ls' t' ]+  -- Type signatures+    C.FunSig r f p rel x t -> (:[]) <$> toAbstract (C.Axiom r f p rel x t)+  -- Function definitions+    C.FunDef r ds f a x cs -> do+        printLocals 10 $ "checking def " ++ show x+        (x',cs') <- toAbstract (OldName x,cs)+        return [ A.FunDef (mkDefInfo x f PublicAccess a r) x' cs' ]++  -- Data definitions+    C.DataDef r f a x pars cons -> withLocalVars $ do+        printScope "scope.data.def" 20 ("checking DataDef for " ++ show x)+        -- Check for duplicate constructors+        do let cs   = map conName cons+               dups = nub $ cs \\ nub cs+               bad  = filter (`elem` dups) cs+           unless (distinct cs) $+             setCurrentRange (getRange bad) $+                typeError $ DuplicateConstructors dups++        pars <- toAbstract pars+        DefinedName p ax <- resolveName (C.QName x)+        let x' = anameName ax+        -- Create the module for the qualified constructors+        checkForModuleClash x -- disallow shadowing previously defined modules+        let m = mnameFromList $ qnameToList x'+        createModule m+        bindModule p x m  -- make it a proper module+        cons <- toAbstract (map (ConstrDecl NoRec m a p) cons)+        -- Open the module+        -- openModule_ (C.QName x) defaultImportDir{ publicOpen = True }+        printScope "data" 20 $ "Checked data " ++ show x+        return [ A.DataDef (mkDefInfo x f PublicAccess a r) x' pars cons ]+      where+        conName (C.Axiom _ _ _ _ c _) = c+        conName _ = __IMPOSSIBLE__++  -- Record definitions (mucho interesting)+    C.RecDef r f a x cm pars fields ->+      withLocalVars $ do+        -- Check that the generated module doesn't clash with a previously+        -- defined module+        checkForModuleClash x+        pars   <- toAbstract pars+        DefinedName p ax <- resolveName (C.QName x)+        let x' = anameName ax+        contel <- toAbstract $ recordConstructorType fields+        m0     <- getCurrentModule+        let m = A.qualifyM m0 $ mnameFromList $ (:[]) $ last $ qnameToList x'+        printScope "rec" 15 "before record"+        createModule m+        afields <- withCurrentModule m $ do+          afields <- toAbstract fields+          printScope "rec" 15 "checked fields"+          return afields+        bindModule p x m+        cm' <- mapM (\(ThingWithFixity c f) -> bindConstructorName m c f a p YesRec) cm+        printScope "rec" 15 "record complete"+        return [ A.RecDef (mkDefInfo x f PublicAccess a r) x' cm' pars contel afields ]++    NiceModule r p a (C.QName name) tel ds ->+      traceCall (ScopeCheckDeclaration $ NiceModule r p a (C.QName name) tel []) $ do       aname <- toAbstract (NewModuleName name)       x <- snd <$> scopeCheckModule r (C.QName name) aname tel ds       bindModule p name aname@@ -799,9 +891,8 @@      NiceModule _ _ _ C.Qual{} _ _ -> __IMPOSSIBLE__ -    NiceModuleMacro r p a x tel e open dir -> case appView e of-      AppView (Ident m) args -> checkModuleMacro Apply r p x tel m args open dir-      _                      -> notAModuleExpr e+    NiceModuleMacro r p a x modapp open dir ->+      checkModuleMacro Apply r p x modapp open dir      NiceOpen r x dir -> do       m <- toAbstract (OldModuleName x)@@ -871,26 +962,38 @@                            })                         m ] -data ConstrDecl = ConstrDecl A.ModuleName C.NiceDeclaration +data IsRecordCon = YesRec | NoRec+data ConstrDecl = ConstrDecl IsRecordCon A.ModuleName IsAbstract Access C.NiceDeclaration++bindConstructorName m x f a p rec = do+  -- The abstract name is the qualified one+  y <- withCurrentModule m $ freshAbstractQName f x+  -- Bind it twice, once unqualified and once qualified+  bindName p' ConName x y+  withCurrentModule m $ bindName p'' ConName x y+  return y+  where+    -- An abstract constructor is private (abstract constructor means+    -- abstract datatype, so the constructor should not be exported).+    p' = case a of+           AbstractDef -> PrivateAccess+           _           -> p+    p'' = case (a, rec) of+            (AbstractDef, _) -> PrivateAccess+            (_, YesRec)      -> OnlyQualified   -- record constructors aren't really in the record module+            _                -> PublicAccess+ instance ToAbstract ConstrDecl A.Declaration where-    toAbstract (ConstrDecl m (C.Axiom r f p a rel x t)) = do -- rel==Relevant-        t' <- toAbstractCtx TopCtx t-        -- The abstract name is the qualified one-        y  <- withCurrentModule m $ freshAbstractQName f x-        -- Bind it twice, once unqualified and once qualified-        bindName p' ConName x y-        withCurrentModule m $ bindName p' ConName x y-        printScope "con" 15 "bound constructor"-        return $ A.Axiom (mkDefInfo x f p a r) rel y t'-        where-            -- An abstract constructor is private (abstract constructor means-            -- abstract datatype, so the constructor should not be exported).-            p' = case (a, p) of-                    (AbstractDef, _) -> PrivateAccess-                    (_, p)           -> p+  toAbstract (ConstrDecl rec m a p (C.Axiom r f _ rel x t)) = do -- rel==Relevant+    t' <- toAbstractCtx TopCtx t+    -- The abstract name is the qualified one+    -- Bind it twice, once unqualified and once qualified+    y <- bindConstructorName m x f a p rec+    printScope "con" 15 "bound constructor"+    return $ A.Axiom (mkDefInfo x f p ConcreteDef r) rel y t' -    toAbstract _ = __IMPOSSIBLE__    -- a constructor is always an axiom+  toAbstract _ = __IMPOSSIBLE__    -- a constructor is always an axiom  instance ToAbstract C.Pragma [A.Pragma] where     toAbstract (C.ImpossiblePragma _) = impossibleTest@@ -916,9 +1019,22 @@       e <- toAbstract $ OldQName x       y <- case e of             A.Def x -> return x-            -- A.Con _ -> fail "Use COMPILED_DATA_EPIC for constructors" -- TODO             _       -> __IMPOSSIBLE__       return [ A.CompiledEpicPragma y ep ]+    toAbstract (C.CompiledJSPragma _ x ep) = do+      e <- toAbstract $ OldQName x+      y <- case e of+            A.Def x -> return x+            A.Con (AmbQ [x]) -> return x+            A.Con x -> fail ("COMPILED_JS used on ambiguous name " ++ show x)+            _       -> __IMPOSSIBLE__+      return [ A.CompiledJSPragma y ep ]+    toAbstract (C.StaticPragma _ x) = do+        e <- toAbstract $ OldQName x+        y <- case e of+            A.Def x -> return x+            _       -> __IMPOSSIBLE__+        return [ A.StaticPragma y ]     toAbstract (C.BuiltinPragma _ b e) = do         e <- toAbstract e         return [ A.BuiltinPragma b e ]@@ -975,11 +1091,15 @@                  | RHS' A.Expr                  | RewriteRHS' [A.Expr] AbstractRHS [A.Declaration] +qualifyName_ :: A.Name -> ScopeM A.QName+qualifyName_ x = do+  m <- getCurrentModule+  return $ A.qualify m x+ withFunctionName :: String -> ScopeM A.QName withFunctionName s = do-  m <- getCurrentModule   NameId i _ <- fresh-  A.qualify m <$> freshName_ (s ++ show i)+  qualifyName_ =<< freshName_ (s ++ show i)  instance ToAbstract AbstractRHS A.RHS where   toAbstract AbsurdRHS'            = return A.AbsurdRHS@@ -1022,7 +1142,7 @@         p <- parseLHS (Just top) lhs         printLocals 10 "before lhs:"         let (x, ps) = lhsArgs p-        x    <- toAbstract (OldName x)+        x    <- withLocalVars $ setLocalVars [] >> toAbstract (OldName x)         args <- toAbstract ps         wps  <- toAbstract =<< mapM (parseLHS Nothing) wps         checkPatternLinearity (map (namedThing . unArg) args ++ wps)@@ -1078,6 +1198,7 @@      -- Removed when parsing     toAbstract (HiddenP _ _) = __IMPOSSIBLE__+    toAbstract (InstanceP _ _) = __IMPOSSIBLE__     toAbstract (RawAppP _ _) = __IMPOSSIBLE__      toAbstract p@(C.WildP r)    = return $ A.WildP (PatSource r $ const p)@@ -1100,7 +1221,7 @@  -- | Turn an operator application into abstract syntax. Make sure to record the -- right precedences for the various arguments.-toAbstractOpApp :: C.Name -> [C.Expr] -> ScopeM A.Expr+toAbstractOpApp :: C.Name -> [OpApp C.Expr] -> ScopeM A.Expr toAbstractOpApp op@(C.NoName _ _) es = __IMPOSSIBLE__ toAbstractOpApp op@(C.Name _ _) es = do     f  <- getFixity (C.QName op)@@ -1113,7 +1234,7 @@          left f (IdPart _ : xs) es = inside f xs es         left f (_ : xs) (e : es) = do-            e  <- toAbstractCtx (LeftOperandCtx f) e+            e  <- toAbstractOpArg (LeftOperandCtx f) e             es <- inside f xs es             return (e : es)         left f (_  : _)  [] = __IMPOSSIBLE__@@ -1122,7 +1243,7 @@         inside f [x]          es       = right f x es         inside f (IdPart _ : xs) es       = inside f xs es         inside f (_  : xs) (e : es) = do-            e  <- toAbstractCtx InsideOperandCtx e+            e  <- toAbstractOpArg InsideOperandCtx e             es <- inside f xs es             return (e : es)         inside _ (_ : _) [] = __IMPOSSIBLE__@@ -1130,6 +1251,6 @@          right _ (IdPart _)  [] = return []         right f _          [e] = do-            e <- toAbstractCtx (RightOperandCtx f) e+            e <- toAbstractOpArg (RightOperandCtx f) e             return [e]         right _ _     _  = __IMPOSSIBLE__

src/full/Agda/Syntax/Translation/InternalToAbstract.hs view

@@ -16,6 +16,7 @@ module Agda.Syntax.Translation.InternalToAbstract where  import Prelude hiding (mapM_, mapM)+import Control.Applicative import Control.Arrow import Control.Monad.State hiding (mapM_, mapM) import Control.Monad.Error hiding (mapM_, mapM)@@ -47,6 +48,7 @@ import Agda.TypeChecking.Datatypes import Agda.TypeChecking.Free import Agda.TypeChecking.Substitute+import Agda.TypeChecking.Telescope  import Agda.Utils.Monad import Agda.Utils.Tuple@@ -56,7 +58,7 @@ #include "../../undefined.h" import Agda.Utils.Impossible -apps :: MonadTCM tcm => (Expr, [Arg Expr]) -> tcm Expr+apps :: (Expr, [Arg Expr]) -> TCM Expr apps (e, []) = return e apps (e, arg : args) | isHiddenArg arg =     do  showImp <- showImplicitArguments@@ -68,11 +70,11 @@ exprInfo :: ExprInfo exprInfo = ExprRange noRange -reifyApp :: MonadTCM tcm => Expr -> [Arg Term] -> tcm Expr+reifyApp :: Expr -> [Arg Term] -> TCM Expr reifyApp e vs = curry apps e =<< reify vs  class Reify i a | i -> a where-    reify :: MonadTCM tcm => i -> tcm a+    reify :: i -> TCM a  instance Reify MetaId Expr where     reify x@(MetaId n) = liftTCM $ do@@ -92,6 +94,9 @@ instance Reify DisplayTerm Expr where   reify d = case d of     DTerm v -> reify v+    DDot  v -> reify v+    DCon c vs -> curry apps (A.Con (AmbQ [c])) =<< reify vs+    DDef f vs -> curry apps (A.Def f) =<< reify vs     DWithApp us vs -> do       us <- reify us       let wapp [e] = e@@ -99,7 +104,7 @@           wapp [] = __IMPOSSIBLE__       reifyApp (wapp us) vs -reifyDisplayForm :: MonadTCM tcm => QName -> Args -> tcm A.Expr -> tcm A.Expr+reifyDisplayForm :: QName -> Args -> TCM A.Expr -> TCM A.Expr reifyDisplayForm x vs fallback = do   enabled <- displayFormsEnabled   if enabled@@ -125,11 +130,19 @@     okDisplayForm (DWithApp (d : ds) []) =       okDisplayForm d && all okDisplayTerm ds     okDisplayForm (DTerm (I.Def f vs)) = all okArg vs-    okDisplayForm _ = True -- False+    okDisplayForm (DDef f vs) = all okDArg vs+    okDisplayForm DDot{} = False+    okDisplayForm DCon{} = False+    okDisplayForm DTerm{} = True -- False?+    okDisplayForm DWithApp{} = True -- False?      okDisplayTerm (DTerm v) = okTerm v+    okDisplayTerm DDot{} = True+    okDisplayTerm DCon{} = True+    okDisplayTerm DDef{} = False     okDisplayTerm _ = False +    okDArg = okDisplayTerm . unArg     okArg = okTerm . unArg      okTerm (I.Var _ []) = True@@ -138,13 +151,11 @@     okTerm _            = True -- False      flattenWith (DWithApp (d : ds) []) = case flattenWith d of-      (f, vs, ds') -> (f, vs, ds' ++ map unDTerm ds)-    flattenWith (DTerm (I.Def f vs)) = (f, vs, [])+      (f, vs, ds') -> (f, vs, ds' ++ ds)+    flattenWith (DDef f vs) = (f, vs, [])+    flattenWith (DTerm (I.Def f vs)) = (f, map (fmap DTerm) vs, [])     flattenWith _ = __IMPOSSIBLE__ -    unDTerm (DTerm v) = v-    unDTerm _ = __IMPOSSIBLE__-     displayLHS ps wps d = case flattenWith d of       (f, vs, ds) -> do         ds <- mapM termToPat ds@@ -154,22 +165,49 @@         info = PatRange noRange         argToPat arg = fmap unnamed <$> traverse termToPat arg -        -- TODO: dot variables-        termToPat (I.Var n []) = return $ ps !! fromIntegral n-        termToPat (I.Con c vs) = A.ConP info (AmbQ [c]) <$> mapM argToPat vs-        termToPat (I.Def _ []) = return $ A.WildP info+        len = genericLength ps++        termToPat :: DisplayTerm -> TCM A.Pattern+        termToPat (DTerm (I.Var n [])) = return $ ps !! fromIntegral n+        termToPat (DCon c vs) = A.ConP info (AmbQ [c]) <$> mapM argToPat vs+        termToPat (DDot v) = A.DotP info <$> termToExpr v+        termToPat (DDef _ []) = return $ A.WildP info+        termToPat (DTerm (I.Con c vs)) = A.ConP info (AmbQ [c]) <$> mapM (argToPat . fmap DTerm) vs+        termToPat (DTerm (I.Def _ [])) = return $ A.WildP info         termToPat v = A.DotP info <$> reify v -- __IMPOSSIBLE__ --- Level literals should be expanded.+        argsToExpr = mapM (traverse termToExpr) +        -- TODO: restructure this to avoid having to repeat the code for reify+        termToExpr :: Term -> TCM A.Expr+        termToExpr (I.Var n [])+          | n < len = return $ patToTerm $ ps !! fromIntegral n+        termToExpr (I.Con c vs) =+          curry apps (A.Con (AmbQ [c])) =<< argsToExpr vs+        termToExpr (I.Def f vs) =+          curry apps (A.Def f) =<< argsToExpr vs+        termToExpr (I.Var n vs) =+          apps =<< (,) <$> reify (I.Var (n - len) []) <*> argsToExpr vs+        termToExpr _ = return $ A.Underscore minfo++        minfo = MetaInfo noRange emptyScopeInfo Nothing+        einfo = ExprRange noRange+        app = foldl (App einfo)++        patToTerm :: A.Pattern -> A.Expr+        patToTerm (A.VarP x)      = A.Var x+        patToTerm (A.ConP _ c ps) =+          A.Con c `app` map (fmap (fmap patToTerm)) ps+        patToTerm (A.DefP _ f ps) =+          A.Def f `app` map (fmap (fmap patToTerm)) ps+        patToTerm (A.WildP _)     = A.Underscore minfo+        patToTerm (A.AsP _ _ p)   = patToTerm p+        patToTerm (A.DotP _ e)    = e+        patToTerm (A.AbsurdP _)   = A.Underscore minfo  -- TODO: could this happen?+        patToTerm (A.LitP l)      = A.Lit l+        patToTerm (A.ImplicitP _) = A.Underscore minfo+ instance Reify Literal Expr where-  reify (LitLevel r n) = do-    levelZero <- primLevelZero-    levelSuc  <- levelSucFunction-    reify $ fold levelSuc levelZero n-    where-    fold s z n | n < 0     = __IMPOSSIBLE__-               | otherwise = foldr (.) id (genericReplicate n s) z   reify l@(LitInt    {}) = return (A.Lit l)   reify l@(LitFloat  {}) = return (A.Lit l)   reify l@(LitString {}) = return (A.Lit l)@@ -183,9 +221,51 @@       I.Var n vs   -> do           x  <- liftTCM $ nameOfBV n `catchError` \_ -> freshName_ ("@" ++ show n)           reifyApp (A.Var x) vs-      I.Def x vs   -> reifyDisplayForm x vs $ do-          n <- getDefFreeVars x-          reifyApp (A.Def x) $ genericDrop n vs+      I.Def x@(QName _ name) vs -> reifyDisplayForm x vs $ do+        mdefn <- liftTCM $ (Just <$> getConstInfo x) `catchError` \_ -> return Nothing+        (pad, vs) <-+          case mdefn of+            Nothing -> (,) [] <$> (flip genericDrop vs <$> getDefFreeVars x)+            Just defn -> do+              let def = theDef defn+              -- This is tricky:+              --  * getDefFreeVars x tells us how many arguments+              --    are part of the local context+              --  * some of those arguments might have been dropped+              --    due to projection likeness+              --  * when showImplicits is on we'd like to see the dropped+              --    projection arguments++              -- We should drop this many arguments from the local context.+              n <- getDefFreeVars x+              -- These are the dropped projection arguments+              pad <- case def of+                      Function{ funProjection = Just (_, np) } -> do+                        TelV tel _ <- telView (defType defn)+                        scope <- getScope+                        let as       = take (np - 1) $ telToList tel+                            whocares = A.Underscore (Info.MetaInfo noRange scope Nothing)+                        return $ map (fmap $ const whocares) as+                      _ -> return []+              -- Now pad' ++ vs' = drop n (pad ++ vs)+              let pad' = genericDrop n pad+                  vs'  = genericDrop (max 0 (n - size pad)) vs+              -- If showImplicit then keep the padding otherwise ignore it+              ifM showImplicitArguments+                  (return (pad', vs'))+                  (return ([], vs'))+        df <- displayFormsEnabled+        if df && isPrefixOf extendlambdaname (show name)+          then do+           reportSLn "int2abs.reifyterm.def" 10 $ "reifying extended lambda with definition: " ++ show x+           info <- getConstInfo x+           cls <- mapM (reify . (NamedClause x)) $ defClauses info+           -- Karim: Currently Abs2Conc does not require a DefInfo thus we+           -- use __IMPOSSIBLE__.+           reifyApp (A.ExtendedLam exprInfo __IMPOSSIBLE__ x cls) vs+          else+           let apps = foldl (\e a -> A.App exprInfo e (fmap unnamed a)) in+           reifyApp (A.Def x `apps` pad) vs       I.Con x vs   -> do         isR <- isGeneratedRecordConstructor x         case isR of@@ -207,18 +287,37 @@             apps (A.Con (AmbQ [x]), genericDrop n $ us ++ es)       I.Lam h b    -> do         (x,e) <- reify b-        return $ A.Lam exprInfo (DomainFree h x) e+        return $ A.Lam exprInfo (DomainFree h Relevant x) e+        -- Andreas, 2011-04-07 we do not need relevance information at internal Lambda       I.Lit l        -> reify l-      I.Pi a b       -> do-        Arg h r a <- reify a-        (x,b)     <- reify b-        return $ A.Pi exprInfo [TypedBindings noRange $ Arg h r [TBind noRange [x] a]] b-      I.Fun a b    -> uncurry (A.Fun $ exprInfo)-                      <$> reify (a,b)+      I.Level l      -> reify l+      I.Pi a b       -> case b of+        NoAbs _ b -> uncurry (A.Fun $ exprInfo) <$> reify (a,b)+        b         -> do+          Arg h r a <- reify a+          (x, b)    <- reify b+          return $ A.Pi exprInfo [TypedBindings noRange $ Arg h r (TBind noRange [x] a)] b       I.Sort s     -> reify s       I.MetaV x vs -> apps =<< reify (x,vs)-      I.DontCare   -> return A.DontCare+      I.DontCare v -> A.DontCare <$> reify v+{- Andreas: I want to see irrelevant, but not implicit arguments+        ifM showImplicitArguments+            (reify v)+            (return A.DontCare)+-}+{- Andreas, 2011-09-09+      I.DontCare Nothing  -> return A.DontCare+      I.DontCare (Just v) -> reify v  -- leads to paradox error msg in test/fail/UnifyWithIrrelevantArgument+-} +instance Reify Elim Expr where+  reify e = case e of+    I.Apply v -> appl "apply" <$> reify v+    I.Proj f  -> appl "proj"  <$> reify (defaultArg $ I.Def f [])+    where+      appl :: String -> Arg Expr -> Expr+      appl s v = A.App exprInfo (A.Lit (LitString noRange s)) $ fmap unnamed v+ data NamedClause = NamedClause QName I.Clause -- Named clause does not need 'Recursion' flag since I.Clause has it -- data NamedClause = NamedClause QName Recursion I.Clause@@ -226,11 +325,10 @@ instance Reify ClauseBody RHS where   reify NoBody     = return AbsurdRHS   reify (Body v)   = RHS <$> reify v-  reify (NoBind b) = reify b   reify (Bind b)   = reify $ absBody b  -- the variables should already be bound -stripImplicits :: MonadTCM tcm => [NamedArg A.Pattern] -> [A.Pattern] ->-                  tcm ([NamedArg A.Pattern], [A.Pattern])+stripImplicits :: [NamedArg A.Pattern] -> [A.Pattern] ->+                  TCM ([NamedArg A.Pattern], [A.Pattern]) stripImplicits ps wps =   ifM showImplicitArguments (return (ps, wps)) $ do   let vars = dotVars (ps, wps)@@ -305,7 +403,10 @@         varOrDot A.ImplicitP{} = True         varOrDot _             = False -+-- | @dotVars ps@ gives all the variables inside of dot patterns of @ps@+--   It is only invoked for patternish things. (Ulf O-tone!)+--   Use it for printing l.h.sides: which of the implicit arguments+--   have to be made explicit. class DotVars a where   dotVars :: a -> Set Name @@ -321,9 +422,14 @@ instance (DotVars a, DotVars b) => DotVars (a, b) where   dotVars (x, y) = Set.union (dotVars x) (dotVars y) ++instance DotVars A.Clause where+  dotVars (A.Clause _ rhs []) = dotVars rhs+  dotVars (A.Clause _ rhs (_:_)) = __IMPOSSIBLE__ -- cannot contain where clauses?+ instance DotVars A.Pattern where   dotVars p = case p of-    A.VarP _      -> Set.empty+    A.VarP _      -> Set.empty   -- do not add pattern vars     A.ConP _ _ ps -> dotVars ps     A.DefP _ _ ps -> dotVars ps     A.DotP _ e    -> dotVars e@@ -333,10 +439,13 @@     A.ImplicitP _ -> Set.empty     A.AsP _ _ p   -> dotVars p +-- | Getting all(!) variables of an expression.+--   It should only get free ones, but it does not matter to include+--   the bound ones. instance DotVars A.Expr where   dotVars e = case e of     A.ScopedExpr _ e -> dotVars e-    A.Var x          -> Set.singleton x+    A.Var x          -> Set.singleton x -- add any expression variable     A.Def _          -> Set.empty     A.Con _          -> Set.empty     A.Lit _          -> Set.empty@@ -346,17 +455,27 @@     A.WithApp _ e es -> dotVars (e, es)     A.Lam _ _ e      -> dotVars e     A.AbsurdLam _ _  -> Set.empty+    A.ExtendedLam _ _ _ cs -> dotVars cs     A.Pi _ tel e     -> dotVars (tel, e)     A.Fun _ a b      -> dotVars (a, b)     A.Set _ _        -> Set.empty     A.Prop _         -> Set.empty     A.Let _ _ _      -> __IMPOSSIBLE__     A.Rec _ es       -> dotVars $ map snd es+    A.RecUpdate _ e es -> dotVars (e, map snd es)     A.ETel _         -> __IMPOSSIBLE__     A.QuoteGoal {}   -> __IMPOSSIBLE__     A.Quote {}       -> __IMPOSSIBLE__-    A.DontCare       -> __IMPOSSIBLE__  -- Set.empty+    A.QuoteTerm {}   -> __IMPOSSIBLE__+    A.Unquote {}     -> __IMPOSSIBLE__+    A.DontCare v     -> dotVars v +instance DotVars RHS where+  dotVars (RHS e) = dotVars e+  dotVars AbsurdRHS = Set.empty+  dotVars (WithRHS _ es clauses) = __IMPOSSIBLE__ -- NZ+  dotVars (RewriteRHS _ es rhs _) = __IMPOSSIBLE__ -- NZ+ instance DotVars TypedBindings where   dotVars (TypedBindings _ bs) = dotVars bs @@ -364,8 +483,7 @@   dotVars (TBind _ _ e) = dotVars e   dotVars (TNoBind e)   = dotVars e -reifyPatterns :: MonadTCM tcm =>-  I.Telescope -> Permutation -> [Arg I.Pattern] -> tcm [NamedArg A.Pattern]+reifyPatterns :: I.Telescope -> Permutation -> [Arg I.Pattern] -> TCM [NamedArg A.Pattern] reifyPatterns tel perm ps = evalStateT (reifyArgs ps) 0   where     reifyArgs as = map (fmap unnamed) <$> mapM reifyArg as@@ -388,8 +506,7 @@         tick         if Set.member "()" vars           then return $ A.DotP i $ A.Underscore mi-          else lift $ A.DotP i <$> reify v-      I.LitP (LitLevel {}) -> __IMPOSSIBLE__+          else return $ A.DotP i t       I.LitP l             -> return (A.LitP l)       I.ConP c _ ps -> A.ConP i (AmbQ [c]) <$> reifyArgs ps       where@@ -418,46 +535,43 @@     reify s =         do  s <- instantiateFull s             case s of-                I.Type (I.Lit (LitLevel _ n)) -> return $ A.Set exprInfo n+                I.Type (I.Max [])                -> return $ A.Set exprInfo 0+                I.Type (I.Max [I.ClosedLevel n]) -> return $ A.Set exprInfo n                 I.Type a -> do                   a <- reify a                   return $ A.App exprInfo (A.Set exprInfo 0)                                           (defaultArg (unnamed a))                 I.Prop       -> return $ A.Prop exprInfo-                I.MetaS x as -> apps =<< reify (x, as)-                I.Suc s      ->-                    do  suc <- freshName_ "suc" -- TODO: hack-                        e   <- reify s-                        return $ A.App exprInfo (A.Var suc) (defaultArg $ unnamed e)                 I.Inf       -> A.Var <$> freshName_ "Setω"                 I.DLub s1 s2 -> do                   lub <- freshName_ "dLub" -- TODO: hack                   (e1,e2) <- reify (s1, I.Lam NotHidden $ fmap Sort s2)                   let app x y = A.App exprInfo x (defaultArg $ unnamed y)                   return $ A.Var lub `app` e1 `app` e2-                I.Lub s1 s2 ->-                    do  lub <- freshName_ "\\/" -- TODO: hack-                        (e1,e2) <- reify (s1,s2)-                        let app x y = A.App exprInfo x (defaultArg $ unnamed y)-                        return $ A.Var lub `app` e1 `app` e2 -instance Reify i a => Reify (Abs i) (Name, a) where-    reify (Abs s v) =-        do  x <- freshName_ s-            e <- addCtx x (defaultArg $ sort I.Prop) -- type doesn't matter-                 $ reify v-            return (x,e)+instance Reify Level Expr where+  reify l = reify =<< reallyUnLevelView l +instance (Free i, Reify i a) => Reify (Abs i) (Name, a) where+  reify (NoAbs x v) = (,) <$> freshName_ x <*> reify v+  reify (Abs s v) = do++    -- If the bound variable is free in the body, then the name "_" is+    -- replaced by "z".+    s <- return $ if s == "_" && 0 `freeIn` v then "z" else s++    x <- freshName_ s+    e <- addCtx x (defaultArg $ sort I.Prop) -- type doesn't matter+         $ reify v+    return (x,e)+ instance Reify I.Telescope A.Telescope where   reify EmptyTel = return []   reify (ExtendTel arg tel) = do     Arg h rel e <- reify arg-    (x,bs)  <- reify $ betterName tel+    (x,bs)  <- reify tel     let r = getRange e-    return $ TypedBindings r (Arg h rel [TBind r [x] e]) : bs-    where-      betterName (Abs "_" x) = Abs "z" x-      betterName (Abs s   x) = Abs s   x+    return $ TypedBindings r (Arg h rel (TBind r [x] e)) : bs  instance Reify i a => Reify (Arg i) (Arg a) where     reify = traverse reify@@ -471,4 +585,4 @@ instance (Reify t t', Reify a a')          => Reify (Judgement t a) (Judgement t' a') where     reify (HasType i t) = HasType <$> reify i <*> reify t-    reify (IsSort i) = IsSort <$> reify i+    reify (IsSort  i t) = IsSort  <$> reify i <*> reify t

src/full/Agda/Termination/SparseMatrix.hs view

@@ -134,7 +134,7 @@     showString "Agda.Termination.Matrix.fromLists " . shows (size m) .     showString " " . shows (toLists m) -instance (Integral i, HasZero b, Pretty b) =>+instance (Show i, Integral i, HasZero b, Pretty b) =>          Pretty (Matrix i b) where   pretty = vcat . map (hsep . map pretty) . toLists @@ -142,7 +142,7 @@          => Arbitrary (Matrix i b) where   arbitrary     = matrix =<< arbitrary -instance (Ord i, Integral i, Enum i, CoArbitrary b, HasZero b) => CoArbitrary (Matrix i b) where+instance (Show i, Ord i, Integral i, Enum i, CoArbitrary b, HasZero b) => CoArbitrary (Matrix i b) where   coarbitrary m = coarbitrary (toLists m)  @@ -199,7 +199,7 @@  -- | Converts a sparse matrix to a sparse list of rows -toSparseRows :: (Num i, Enum i) => Matrix i b -> [(i,[(i,b)])]+toSparseRows :: (Eq i, Num i, Enum i) => Matrix i b -> [(i,[(i,b)])] toSparseRows m = aux 1 [] (unM m)   where aux i' [] []  = []         aux i' row [] = [(i', reverse row)]@@ -208,7 +208,7 @@             | otherwise = (i', reverse row) : aux i [(j,b)] m  -- sparse vectors cannot have two entries in one column-blowUpSparseVec :: (Ord i, Num i, Enum i) => b -> i -> [(i,b)] -> [b]+blowUpSparseVec :: (Show i, Ord i, Num i, Enum i) => b -> i -> [(i,b)] -> [b] blowUpSparseVec zero n l = aux 1 l   where aux i [] | i > n = []                  | otherwise = zero : aux (i+1) []@@ -219,7 +219,7 @@  -- | Converts a matrix to a list of row lists. -toLists :: (Ord i, Integral i, Enum i, HasZero b) => Matrix i b -> [[b]]+toLists :: (Show i, Ord i, Integral i, Enum i, HasZero b) => Matrix i b -> [[b]] toLists m = blowUpSparseVec emptyRow (rows sz) $     map (\ (i,r) -> (i, blowUpSparseVec zeroElement (cols sz) r)) $ toSparseRows m --            [ [ maybe zeroElement id $ lookup (MIx { row = r, col = c }) (unM m)@@ -355,7 +355,7 @@ -- -- Precondition: @'square' m@. -diagonal :: (Enum i, Num i, Ix i, HasZero b) => Matrix i b -> Array i b+diagonal :: (Show i, Enum i, Num i, Ix i, HasZero b) => Matrix i b -> Array i b diagonal m = listArray (1, rows sz) $ blowUpSparseVec zeroElement (rows sz) $   map (\ ((MIx i j),b) -> (i,b)) $ filter (\ ((MIx i j),b) -> i==j) (unM m)   where sz = size m

src/full/Agda/Termination/TermCheck.hs view

@@ -12,6 +12,7 @@     , Result, DeBruijnPat     ) where +import Control.Applicative import Control.Monad.Error import Data.List as List import qualified Data.Map as Map@@ -19,7 +20,6 @@ import qualified Data.Maybe as Maybe import qualified Data.Set as Set import Data.Set (Set)-import Text.PrettyPrint (Doc)  import qualified Agda.Syntax.Abstract as A import Agda.Syntax.Internal@@ -44,6 +44,8 @@ import Agda.TypeChecking.Monad.Builtin import Agda.TypeChecking.Monad.Signature (isProjection) import Agda.TypeChecking.Primitive (constructorForm)+import Agda.TypeChecking.Level (reallyUnLevelView)+import Agda.TypeChecking.Substitute  import qualified Agda.Interaction.Highlighting.Range as R import Agda.Interaction.Options@@ -54,15 +56,12 @@ #include "../undefined.h" import Agda.Utils.Impossible -type Calls = Term.CallGraph (Set R.Range)+type Calls = Term.CallGraph (Set CallInfo) type MutualNames = [QName] --- | The result of termination checking a module is a list of--- problematic mutual blocks (represented by the names of the--- functions in the block), along with the ranges for the problematic--- call sites (call site paths).+-- | The result of termination checking a module. -type Result = [([A.QName], [R.Range])]+type Result = [TerminationError]  -- | Termination check a sequence of declarations. termDecls :: [A.Declaration] -> TCM Result@@ -77,13 +76,13 @@     A.Axiom {}            -> return []     A.Field {}            -> return []     A.Primitive {}        -> return []-    A.Definition _ _ ds-      | [A.RecDef _ r _ _ _ rds] <- unscopeDefs ds+    A.Mutual _ ds+      | [A.RecSig{}, A.RecDef _ r _ _ _ rds] <- unscopeDefs ds                           -> do         let m = mnameFromList $ qnameToList r         setScopeFromDefs ds         termSection m rds-    A.Definition i ts ds  -> termMutual i ts ds+    A.Mutual i ds  -> termMutual i ds     A.Section _ x _ ds    -> termSection x ds     A.Apply {}            -> return []     A.Import {}           -> return []@@ -92,15 +91,20 @@         -- open is just an artifact from the concrete syntax     A.ScopedDecl{}        -> __IMPOSSIBLE__         -- taken care of above+    -- These should all be wrapped in mutual blocks+    A.FunDef{}  -> __IMPOSSIBLE__+    A.DataSig{} -> __IMPOSSIBLE__+    A.DataDef{} -> __IMPOSSIBLE__+    A.RecSig{}  -> __IMPOSSIBLE__+    A.RecDef{}  -> __IMPOSSIBLE__   where     setScopeFromDefs = mapM_ setScopeFromDef-    setScopeFromDef (A.ScopedDef scope d) =-      setScope scope >> setScopeFromDef d+    setScopeFromDef (A.ScopedDecl scope d) = setScope scope     setScopeFromDef _ = return ()      unscopeDefs = concatMap unscopeDef -    unscopeDef (A.ScopedDef _ d) = unscopeDef d+    unscopeDef (A.ScopedDecl _ ds) = unscopeDefs ds     unscopeDef d = [d]  collectCalls :: (a -> TCM Calls) -> [a] -> TCM Calls@@ -110,8 +114,8 @@                              return (c1 `Term.union` c2)  -- | Termination check a bunch of mutually inductive recursive definitions.-termMutual :: Info.DeclInfo -> [A.TypeSignature] -> [A.Definition] -> TCM Result-termMutual i ts ds = if names == [] then return [] else+termMutual :: Info.DeclInfo -> [A.Declaration] -> TCM Result+termMutual i ds = if names == [] then return [] else   do -- get list of sets of mutually defined names from the TCM      -- this includes local and auxiliary functions introduced      -- during type-checking@@ -175,24 +179,24 @@                    ]                  return $ Term.terminates calls2      case r of-       Left  errDesc -> do-         let callSites = Set.toList errDesc-         return [(names, callSites)] -- TODO: this could be changed to-                                     -- [(allNames, callSites)]+       Left calls -> do+         return [TerminationError+                   { termErrFunctions = names+                     -- TODO: This could be changed to allNames.+                   , termErrCalls     = Set.toList calls+                   }+                ]        Right _ -> do          reportSLn "term.warn.yes" 2                      (show (names) ++ " does termination check")          return []   where   getName (A.FunDef i x cs)       = [x]-  getName (A.ScopedDef _ d)       = getName d-  getName (A.RecDef _ _ _ _ _ ds) = concatMap getNameD ds-  getName _                       = []--  getNameD (A.Definition _ _ ds) = concatMap getName ds-  getNameD (A.Section _ _ _ ds)  = concatMap getNameD ds-  getNameD (A.ScopedDecl _ ds)   = concatMap getNameD ds-  getNameD _                     = []+  getName (A.RecDef _ _ _ _ _ ds) = concatMap getName ds+  getName (A.Mutual _ ds)       = concatMap getName ds+  getName (A.Section _ _ _ ds)  = concatMap getName ds+  getName (A.ScopedDecl _ ds)   = concatMap getName ds+  getName _                     = []    -- the mutual names mentioned in the abstract syntax   names = concatMap getName ds@@ -225,8 +229,7 @@ 	      ]         case (theDef def) of           Function{ funClauses = cls } ->-            collectCalls (termClause use names name) $-              map translatedClause cls+            collectCalls (termClause use names name) cls           _ -> return Term.empty  @@ -300,7 +303,7 @@ termToDBP conf t   | not $ useDotPatterns conf = return $ unusedVar   | otherwise                 = do-    t <- constructorForm t+    t <- stripProjections =<< constructorForm t     case t of       Var i []    -> return $ VarDBP i       Con c args  -> ConDBP c <$> mapM (termToDBP conf . unArg) args@@ -335,12 +338,8 @@ -} stripBind :: DBPConf -> Nat -> Pattern -> ClauseBody -> TCM (Maybe (Nat, DeBruijnPat, ClauseBody)) stripBind _ _ _ NoBody            = return Nothing-stripBind conf i (VarP x) (NoBind b) = return $ Just (i, unusedVar, b) stripBind conf i (VarP x) (Bind b)   = return $ Just (i - 1, VarDBP i, absBody b) stripBind conf i (VarP x) (Body b)   = __IMPOSSIBLE__-stripBind conf i (DotP t) (NoBind b) = do-  t <- termToDBP conf t-  return $ Just (i, t, b) stripBind conf i (DotP t) (Bind b)   = do   t <- termToDBP conf t   return $ Just (i - 1, t, absBody b)@@ -374,8 +373,9 @@ termClause use names name (Clause { clauseTel  = tel                                   , clausePerm = perm                                   , clausePats = argPats'-                                  , clauseBody = body }) = do-    argPats' <- addCtxTel tel $ normalise argPats'+                                  , clauseBody = body }) =+  addCtxTel tel $ do+    argPats' <- normalise argPats'     -- The termination checker doesn't know about reordered telescopes     let argPats = substs (renamingR perm) argPats'     dbs <- stripBinds use (nVars - 1) (map unArg argPats) body@@ -390,7 +390,6 @@   where     nVars = boundVars body     boundVars (Bind b)   = 1 + boundVars (absBody b)-    boundVars (NoBind b) = boundVars b     boundVars NoBody     = 0     boundVars (Body _)   = 0 @@ -416,17 +415,15 @@        loopSort :: (?cutoff :: Int) => [DeBruijnPat] -> Sort -> TCM Calls        loopSort pats s = do          case s of-           Type t -> loop pats Term.unknown t+           Type (Max [])              -> return Term.empty+           Type (Max [ClosedLevel _]) -> return Term.empty+           Type t -> loop pats Term.unknown (Level t)            Prop   -> return Term.empty            Inf    -> return Term.empty-           Lub s1 s2 -> liftM2 Term.union-             (loopSort pats s1)-             (loopSort pats s2)-           DLub s1 (Abs x s2) -> liftM2 Term.union+           DLub s1 (NoAbs x s2) -> Term.union <$> loopSort pats s1 <*> loopSort pats s2+           DLub s1 (Abs x s2)   -> liftM2 Term.union              (loopSort pats s1)-             (loopSort (map liftDBP pats) s2)-           Suc s -> loopSort pats s-           MetaS _ _ -> return Term.empty  -- see comment on MetaV below+             (addCtxString x __IMPOSSIBLE__ $ loopSort (map liftDBP pats) s2)         loopType :: (?cutoff :: Int) => [DeBruijnPat] -> Order -> Type -> TCM Calls        loopType pats guarded (El s t) = liftM2 Term.union@@ -472,8 +469,8 @@                args2 <- mapM instantiateFull args1                 -- We have to reduce constructors in case they're reexported.-               let reduceCon t@(Con _ _) = reduce t-                   reduceCon t           = return t+               let reduceCon (Con c vs) = (`apply` vs) <$> reduce (Con c [])  -- make sure we don't reduce the arguments+                   reduceCon t          = return t                args2 <- mapM reduceCon args2                args  <- mapM etaContract args2 @@ -482,7 +479,7 @@                isProj <- isProjection g                let unguards = repeat Term.unknown                let guards = maybe unguards -- not a proj. ==> unguarded-                              (\ n -> take (n - 1) unguards ++ guarded : unguards)+                              (\ _ -> guarded : unguards)                                 -- proj. => preserve g. of princ. arg. (counting starts with 1)                               isProj                -- collect calls in the arguments of this call@@ -516,30 +513,33 @@                                <+> hsep (map prettyTCM pats)                             , nest 2 $ text "to" <+> prettyTCM g <+>                                         hsep (map (parens . prettyTCM) args)-                            , nest 2 $ text ("call matrix (with guardeness): " ++ show matrix')+                            , nest 2 $ text ("call matrix (with guardedness): " ++ show matrix')                             ]) +                     doc <- prettyTCM (Def g args0)                      return                        (Term.insert                          (Term.Call { Term.source = fInd                                     , Term.target = toInteger gInd'                                     , Term.cm     = makeCM ncols nrows matrix'                                     })-                         -- Note that only the base part of the-                         -- name is collected here.-                         (Set.fromList $ fst $ R.getRangesA g)+                         (Set.singleton+                            (CallInfo { callInfoRange = getRange g+                                      , callInfoCall  = show doc+                                      }))                          calls)            case t of              -- Constructed value.-            Con c args ->-              constructor c Inductive $ zip args (repeat True)+            Con c args+              | Just c == sharp conf ->+                constructor c CoInductive $ zip args (repeat True)+              | otherwise ->+                constructor c Inductive $ zip args (repeat True)              Def g args0-              | Just g == sharp conf ->-                constructor g CoInductive $ zip args0 (repeat True)               | guardingTypeConstructors conf -> do                 gDef <- theDef <$> getConstInfo g                 case gDef of@@ -550,7 +550,8 @@               where               -- Data or record type constructor.               con occs =-                constructor g Inductive $+                constructor g Inductive $   -- guardedness preserving+                -- constructor g CoInductive $ -- guarding! (Andreas, 2011-04-10) -- does not work, might lead to infinite unfolding in eq. checking (Ripley!)                   zip args0 (map preserves occs ++ repeat False)                 where                 preserves Positive = True@@ -561,19 +562,25 @@               fun = function g args0              -- Abstraction. Preserves guardedness.-            Lam h (Abs x t) -> loop (map liftDBP pats) guarded t+            Lam h (Abs x t) -> addCtxString x (Arg { argHiding    = h+                                                   , argRelevance = __IMPOSSIBLE__+                                                   , unArg        = __IMPOSSIBLE__+                                                   }) $+              loop (map liftDBP pats) guarded t+            Lam h (NoAbs _ t) -> loop pats guarded t              -- Neutral term. Destroys guardedness.             Var i args -> collectCalls (loop pats Term.unknown) (map unArg args)              -- Dependent function space.-            Pi a (Abs _ b) ->+            Pi a (Abs x b) ->                do g1 <- loopType pats Term.unknown (unArg a)-                  g2 <- loopType (map liftDBP pats) piArgumentGuarded b+                  g2 <- addCtxString x a $+                        loopType (map liftDBP pats) piArgumentGuarded b                   return $ g1 `Term.union` g2              -- Non-dependent function space.-            Fun a b ->+            Pi a (NoAbs _ b) ->                do g1 <- loopType pats Term.unknown (unArg a)                   g2 <- loopType pats piArgumentGuarded b                   return $ g1 `Term.union` g2@@ -588,15 +595,19 @@ 	    -- will be a warning for them anyway.             MetaV x args -> return Term.empty -            -- Erased proof.-            DontCare -> return Term.empty+            -- Erased and not-yet-erased proof.+            DontCare t -> loop pats guarded t +            -- Level.+            Level l -> loop pats guarded =<< reallyUnLevelView l+          where          -- Should function and Π type constructors be treated as          -- preserving guardedness in their right arguments?          piArgumentGuarded =            if guardingTypeConstructors conf then-             guarded+             guarded   -- preserving guardedness+             -- Term.lt      -- guarding! (Andreas, 2011-04-10)  -- SEE ABOVE             else              Term.unknown @@ -657,17 +668,61 @@   LitDBP _    -> []  compareTerm :: (?cutoff :: Int) => Maybe QName -> Term -> DeBruijnPat -> TCM Term.Order-compareTerm suc t p = compareTerm' suc t p+compareTerm suc t p = do+  t <- stripAllProjections t+  compareTerm' suc t p+ {- compareTerm t p = Term.supremum $ compareTerm' t p : map cmp (subPatterns p)   where     cmp p' = (Term..*.) Term.lt (compareTerm' t p') -} +-- | Remove projections until a term is no longer a projection.+--   Also, remove 'DontCare's.+stripProjections :: Term -> TCM Term+stripProjections (DontCare t) = stripProjections t+stripProjections t@(Def qn ts@(~(r : _))) = do+  isProj <- isProjection qn+  case isProj of+    Just{} | not (null ts) -> stripProjections $ unArg r+    _ -> return t+stripProjections t = return t++-- | Remove all projections from an algebraic term (not going under binders).+class StripAllProjections a where+  stripAllProjections :: a -> TCM a++instance StripAllProjections a => StripAllProjections (Arg a) where+  stripAllProjections (Arg h r a) = Arg h r <$> stripAllProjections a++instance StripAllProjections a => StripAllProjections [a] where+  stripAllProjections = mapM stripAllProjections++instance StripAllProjections Term where+  stripAllProjections t = do+    t <- stripProjections t+    case t of+      Con c ts -> Con c <$> stripAllProjections ts+      Def d ts -> Def d <$> stripAllProjections ts+      _ -> return t++{-+-- | Remove all projections from an algebraic term (not going under binders).+stripAllProjections :: Term -> TCM Term+stripAllProjections t = do+  t <- stripProjections t+  case t of+    Con c ts -> Con c <$> mapM stripAllProjections ts+    Def d ts -> Def d <$> mapM stripAllProjections ts+    _ -> return t+-}+ -- | compareTerm t dbpat --   Precondition: top meta variable resolved compareTerm' :: (?cutoff :: Int) => Maybe QName -> Term -> DeBruijnPat -> TCM Term.Order-compareTerm' _ (Var i _)  p              = compareVar i p+compareTerm' _ (Var i _)      p = compareVar i p+compareTerm' suc (DontCare t) p = compareTerm' suc t p compareTerm' _ (Lit l)    (LitDBP l')   | l == l'   = return Term.le   | otherwise = return Term.unknown@@ -676,17 +731,19 @@   case t of     Lit _ -> return Term.unknown     _     -> compareTerm' suc t p+-- Andreas, 2011-04-19 give subterm priority over matrix order+compareTerm' _ t@Con{} (ConDBP c ps)+  | any (isSubTerm t) ps = decreaseFromConstructor c compareTerm' suc (Con c ts) (ConDBP c' ps)   | c == c' = compareConArgs suc ts ps compareTerm' suc (Def s ts) (ConDBP s' ps)   | s == s' && Just s == suc = compareConArgs suc ts ps-compareTerm' _ t@Con{} (ConDBP c ps)-  | any (isSubTerm t) ps = decreaseFromConstructor c -- new cases for counting constructors / projections -- register also increase compareTerm' suc (Def s ts) p | Just s == suc = do     os <- mapM (\ t -> compareTerm' suc (unArg t) p) ts     return $ decr (-1) .*. infimum os+{- Andreas 2011-07-07 Projections are now being removed in a preprocess -- projections are size preserving compareTerm' suc (Def qn ts) p = do     isProj <- isProjection qn@@ -696,10 +753,12 @@         compareTerm' suc (unArg (ts !! (n - 1))) p       -- not a projection or underapplied:       _ -> return Term.unknown+-} compareTerm' suc (Con c ts) p = do     os <- mapM (\ t -> compareTerm' suc (unArg t) p) ts     oc <- increaseFromConstructor c     return $ if (null os) then Term.unknown else oc .*. infimum os+compareTerm' suc t p | isSubTerm t p = return Term.le compareTerm' _ _ _ = return Term.unknown  -- TODO: isSubTerm should compute a size difference (Term.Order)

src/full/Agda/TypeChecking/Abstract.hs view

@@ -14,7 +14,7 @@ piAbstractTerm :: Term -> Type -> Type -> Type piAbstractTerm v a b = fun a (abstractTerm v b)   where-    fun a b = El s $ Pi (Arg NotHidden Relevant a) $ Abs "w" b+    fun a b = El s $ Pi (Arg NotHidden Relevant a) $ mkAbs "w" b       where s = (sLub `on` getSort) a b  class AbstractTerm a where@@ -29,38 +29,55 @@     Def c vs    -> Def c $ absT vs     Con c vs    -> Con c $ absT vs     Pi a b      -> uncurry Pi $ absT (a, b)-    Fun a b      -> uncurry Fun $ absT (a, b)     Lit l       -> Lit l+    Level l     -> Level $ absT l     Sort s      -> Sort $ absT s     MetaV m vs  -> MetaV m $ absT vs-    DontCare    -> DontCare+    DontCare mv -> DontCare $ absT mv     where       absT x = abstractTerm u x  instance AbstractTerm Type where-  abstractTerm u (El s v) = El s $ abstractTerm u v+  abstractTerm u (El s v) = El (abstractTerm u s) (abstractTerm u v)  instance AbstractTerm Sort where   abstractTerm u s = case s of     Type n     -> Type $ absS n     Prop       -> Prop-    Suc s      -> Suc $ absS s-    Lub s1 s2  -> Lub (absS s1) (absS s2)-    MetaS m as -> MetaS m (absS as)     Inf        -> Inf     DLub s1 s2 -> DLub (absS s1) (absS s2)     where absS x = abstractTerm u x +instance AbstractTerm Level where+  abstractTerm u (Max as) = Max $ abstractTerm u as++instance AbstractTerm PlusLevel where+  abstractTerm u l@ClosedLevel{} = l+  abstractTerm u (Plus n l) = Plus n $ abstractTerm u l++instance AbstractTerm LevelAtom where+  abstractTerm u l = case l of+    MetaLevel m vs   -> MetaLevel m    $ abstractTerm u vs+    NeutralLevel v   -> NeutralLevel   $ abstractTerm u v+    BlockedLevel _ v -> UnreducedLevel $ abstractTerm u v -- abstracting might remove the blockage+    UnreducedLevel v -> UnreducedLevel $ abstractTerm u v+ instance AbstractTerm a => AbstractTerm (Arg a) where   abstractTerm = fmap . abstractTerm  instance AbstractTerm a => AbstractTerm [a] where   abstractTerm = fmap . abstractTerm -instance (Subst a, AbstractTerm a) => AbstractTerm (Abs a) where-  abstractTerm u (Abs x v) = Abs x $ swap $ abstractTerm (raise 1 u) v+instance AbstractTerm a => AbstractTerm (Maybe a) where+  abstractTerm = fmap . abstractTerm++instance (Raise a, AbstractTerm a) => AbstractTerm (Abs a) where+  abstractTerm u (NoAbs x v) = NoAbs x $ abstractTerm u v+  abstractTerm u (Abs   x v) = Abs x $ rename swap $ abstractTerm (raise 1 u) v     where-      swap = substs $ [Var 1 [], Var 0 []] ++ [Var i [] | i <- [2..]]+      swap 0 = 1+      swap 1 = 0+      swap i = i  instance (AbstractTerm a, AbstractTerm b) => AbstractTerm (a, b) where   abstractTerm u (x, y) = (abstractTerm u x, abstractTerm u y)

src/full/Agda/TypeChecking/CompiledClause.hs view

@@ -1,4 +1,4 @@-{-# LANGUAGE TypeOperators, CPP, DeriveDataTypeable #-}+{-# LANGUAGE TypeOperators, CPP, DeriveDataTypeable, DeriveFunctor #-} module Agda.TypeChecking.CompiledClause where  import qualified Data.Map as Map@@ -9,80 +9,33 @@ import Agda.Syntax.Common import Agda.Syntax.Internal import Agda.Syntax.Literal-import Agda.Utils.List import Agda.Utils.Pretty -import Agda.Utils.Impossible-#include "../undefined.h"- type key :-> value = Map key value  data Case c = Branches { conBranches    :: QName   :-> c                        , litBranches    :: Literal :-> c                        , catchAllBranch :: Maybe c                        }-  deriving (Typeable, Data)+  deriving (Typeable, Data, Functor)  data CompiledClauses   = Case Int (Case CompiledClauses)-  | Done Int Term+    -- ^ @Case n bs@ stands for a match on the @n@-th argument+    -- (counting from zero) with @bs@ as the case branches.+  | Done [Arg String] Term+    -- ^ @Done xs b@ stands for the body @b@ where the @xs@ contains hiding+    --   and name suggestions for the free variables. This is needed to build+    --   lambdas on the right hand side for partial applications which can+    --   still reduce.   | Fail+    -- ^ Absurd case.   deriving (Typeable, Data) --- | Note that it is the /translated/ clauses which are compiled, not--- the original ones.--compileClauses :: [Clauses] -> CompiledClauses-compileClauses cs =-  compile [ (clausePats c, clauseBody c)-          | Clauses { translatedClause = c } <- cs-          ]--type Cl  = ([Arg Pattern], ClauseBody)-type Cls = [Cl]--compile :: Cls -> CompiledClauses-compile cs = case nextSplit cs of-  Just n  -> Case n $ fmap compile $ splitOn n cs-  Nothing -> case map getBody cs of-    [Just (m, t)] -> Done m t-    _             -> Fail-  where-    getBody (_, b) = body b-    body (Bind b)   = inc $ body (absBody b)-    body (NoBind b) = body b-    body (Body t)   = Just (0, t)-    body NoBody     = Nothing-    inc Nothing       = Nothing-    inc (Just (n, t)) = Just (n + 1, t)--nextSplit :: Cls -> Maybe Int-nextSplit [] = __IMPOSSIBLE__-nextSplit ((ps, _):_) = mhead [ n | (a, n) <- zip ps [0..], isPat (unArg a) ]-  where-    isPat VarP{} = False-    isPat DotP{} = False-    isPat ConP{} = True-    isPat LitP{} = True--splitOn :: Int -> Cls -> Case Cls-splitOn n cs = mconcat $ map (fmap (:[]) . splitC n) cs--splitC :: Int -> Cl -> Case Cl-splitC n (ps, b) = case unArg p of-  ConP c _ qs -> conCase c (ps0 ++ qs ++ ps1, b)-  LitP l      -> litCase l (ps0 ++ ps1, b)-  _           -> catchAll (ps, b)-  where-    (ps0, p, ps1) = extractNthElement' n ps- litCase l x = Branches Map.empty (Map.singleton l x) Nothing conCase c x = Branches (Map.singleton c x) Map.empty Nothing catchAll x  = Branches Map.empty Map.empty (Just x) -instance Functor Case where-  fmap f (Branches cs ls m) = Branches (fmap f cs) (fmap f ls) (fmap f m)- instance Monoid m => Monoid (Case m) where   mempty = Branches Map.empty Map.empty Nothing   mappend (Branches cs  ls  m)@@ -108,7 +61,7 @@              | (x, v) <- Map.toList m ]  instance Pretty CompiledClauses where-  pretty (Done m t)  = text ("done[" ++ show m ++ "]") <+> text (show t)+  pretty (Done hs t)  = text ("done" ++ show hs) <+> text (show t)   pretty Fail        = text "fail"   pretty (Case n bs) =     sep [ text ("case " ++ show n ++ " of")

+ src/full/Agda/TypeChecking/CompiledClause/Compile.hs view

@@ -0,0 +1,124 @@+{-# LANGUAGE CPP #-}+module Agda.TypeChecking.CompiledClause.Compile where++import Data.Monoid+import qualified Data.Map as Map+import Data.List (genericReplicate, nubBy)+import Data.Function++import Agda.Syntax.Common+import Agda.Syntax.Internal+import Agda.TypeChecking.CompiledClause+import Agda.TypeChecking.Monad+import Agda.TypeChecking.RecordPatterns+import Agda.TypeChecking.Substitute+import Agda.TypeChecking.Pretty+import Agda.Utils.List++import Agda.Utils.Impossible+#include "../../undefined.h"++compileClauses ::+  Bool -- ^ Translate record patterns?+  -> [Clause] -> TCM CompiledClauses+compileClauses translate cs = do+  cs <- if translate then+          mapM translateRecordPatterns cs+         else+          return cs+  return $ compile [(clausePats c, clauseBody c) | c <- cs]++type Cl  = ([Arg Pattern], ClauseBody)+type Cls = [Cl]++compile :: Cls -> CompiledClauses+compile cs = case nextSplit cs of+  Just n  -> Case n $ fmap compile $ splitOn n cs+  Nothing -> case map getBody cs of+    -- It's possible to get more than one clause here due to+    -- catch-all expansion.+    Just t : _  -> Done (map (fmap name) $ fst $ head cs) t+    Nothing : _ -> Fail+    []          -> __IMPOSSIBLE__+  where+    name (VarP x) = x+    name (DotP _) = "_"+    name ConP{} = __IMPOSSIBLE__+    name LitP{} = __IMPOSSIBLE__+    getBody (_, b) = body b+    body (Bind b)   = body (absBody b)+    body (Body t)   = Just t+    body NoBody     = Nothing++nextSplit :: Cls -> Maybe Int+nextSplit [] = __IMPOSSIBLE__+nextSplit ((ps, _):_) = mhead [ n | (a, n) <- zip ps [0..], isPat (unArg a) ]+  where+    isPat VarP{} = False+    isPat DotP{} = False+    isPat ConP{} = True+    isPat LitP{} = True++splitOn :: Int -> Cls -> Case Cls+splitOn n cs = mconcat $ map (fmap (:[]) . splitC n) $ expandCatchAlls n cs++splitC :: Int -> Cl -> Case Cl+splitC n (ps, b) = case unArg p of+  ConP c _ qs -> conCase c (ps0 ++ qs ++ ps1, b)+  LitP l      -> litCase l (ps0 ++ ps1, b)+  _           -> catchAll (ps, b)+  where+    (ps0, p, ps1) = extractNthElement' n ps++-- Expand catch-alls that appear before actual matches.+expandCatchAlls :: Int -> Cls -> Cls+expandCatchAlls n cs = case cs of+  _            | all (isCatchAll . nth . fst) cs -> cs+  (ps, b) : cs | not (isCatchAll (nth ps)) -> (ps, b) : expandCatchAlls n cs+               | otherwise -> map (expand ps b) expansions ++ (ps, b) : expandCatchAlls n cs+  _ -> __IMPOSSIBLE__+  where+    isCatchAll (Arg _ _ ConP{}) = False+    isCatchAll (Arg _ _ LitP{}) = False+    isCatchAll _      = True+    nth qs = p+      where (_, p, _) = extractNthElement' n qs++    classify (LitP l)     = Left l+    classify (ConP c _ _) = Right c+    classify _            = __IMPOSSIBLE__++    -- All non-catch-all patterns following this one (at position n).+    -- These are the cases the wildcard needs to be expanded into.+    expansions = nubBy ((==) `on` classify)+               . map unArg+               . filter (not . isCatchAll)+               . map (nth . fst) $ cs++    expand ps b q =+      case q of+        ConP c _ qs' -> (ps0 ++ [defaultArg $ ConP c Nothing (genericReplicate m $ defaultArg $ VarP "_")] ++ ps1,+                         substBody n' m (Con c (map var [m - 1, m - 2..0])) b)+          where m = fromIntegral $ length qs'+        LitP l -> (ps0 ++ [defaultArg $ LitP l] ++ ps1, substBody n' 0 (Lit l) b)+        _ -> __IMPOSSIBLE__+      where+        (ps0, _, ps1) = extractNthElement' n ps++        n' = countVars ps0+        countVars = sum . map (count . unArg)+        count VarP{}        = 1+        count (ConP _ _ ps) = countVars ps+        count DotP{}        = 1   -- dot patterns are treated as variables in the clauses+        count _             = 0++        var x = defaultArg $ Var x []++substBody :: Int -> Integer -> Term -> ClauseBody -> ClauseBody+substBody _ _ _ NoBody = NoBody+substBody 0 m v b = case b of+  Bind   b -> foldr (.) id (genericReplicate m (Bind . Abs "_")) $ subst v (absBody $ raise m b)+  _        -> __IMPOSSIBLE__+substBody n m v b = case b of+  Bind b   -> Bind $ fmap (substBody (n - 1) m v) b+  _        -> __IMPOSSIBLE__

+ src/full/Agda/TypeChecking/CompiledClause/Compile.hs-boot view

@@ -0,0 +1,7 @@+module Agda.TypeChecking.CompiledClause.Compile where++import Agda.Syntax.Internal+import Agda.TypeChecking.CompiledClause+import Agda.TypeChecking.Monad.Base++compileClauses :: Bool -> [Clause] -> TCM CompiledClauses

src/full/Agda/TypeChecking/CompiledClause/Match.hs view

@@ -4,6 +4,7 @@ import Control.Applicative import qualified Data.Map as Map import Data.Traversable+import Data.List  import Agda.Syntax.Internal import Agda.Syntax.Common@@ -27,46 +28,58 @@  match :: CompiledClauses -> MaybeReducedArgs -> (Args -> Args) -> Stack -> TCM (Reduced (Blocked Args) Term) match Fail args patch stack = return $ NoReduction $ NotBlocked (patch $ map ignoreReduced args)-match (Done _ t) args _ _ =-  return $ YesReduction $ substs (reverse $ map (unArg . ignoreReduced) args) t-match (Case n bs) args patch stack = do-  let (args0, MaybeRed red (Arg h r v0), args1) = extractNthElement' n args-  w  <- case red of-          Reduced b  -> return $ fmap (const v0) b-          NotReduced ->-            unfoldCorecursion =<< instantiate v0-  cv <- constructorForm $ ignoreBlocking w-  let v      = ignoreBlocking w-      args'  = args0 ++ [MaybeRed red $ Arg h r v] ++ args1-      stack' = maybe [] (\c -> [(c, args', patch)]) (catchAllBranch bs)-               ++ stack-      patchLit args = patch (args0 ++ [Arg h r v] ++ args1)-        where (args0, args1) = splitAt n args-      patchCon c m args = patch (args0 ++ [Arg h r $ Con c vs] ++ args1)-        where (args0, args1') = splitAt n args-              (vs, args1)     = splitAt m args1'-  case w of-    Blocked x _            -> return $ NoReduction $ Blocked x (patch $ map ignoreReduced args')-    NotBlocked (MetaV x _) -> return $ NoReduction $ Blocked x (patch $ map ignoreReduced args')-    NotBlocked (Lit l) -> case Map.lookup l (litBranches bs) of-      Nothing -> match' stack''-      Just cc -> match cc (args0 ++ args1) patchLit stack''-      where-        stack'' = (++ stack') $ case cv of-          Con c vs -> case Map.lookup c (conBranches bs) of-            Nothing -> []-            Just cc -> [(cc, args0 ++ map (MaybeRed red) vs ++ args1, patchCon c (length vs))]-          _        -> []-    NotBlocked (Con c vs) -> case Map.lookup c (conBranches bs) of-      Nothing -> match' stack'-      Just cc -> match cc (args0 ++ map (MaybeRed red) vs ++ args1)-                          (patchCon c (length vs)) stack'-    NotBlocked _ -> return $ NoReduction $ NotBlocked (patch $ map ignoreReduced args')+match (Done xs t) args _ _+  | m < n     = return $ YesReduction $ substs (reverse $ toTm args)+                                      $ foldr lam t (drop m xs)+  | otherwise = return $ YesReduction $ substs (reverse $ toTm args0) t `apply` map ignoreReduced args1+  where+    n              = length xs+    m              = length args+    toTm           = map (unArg . ignoreReduced)+    (args0, args1) = splitAt n args+    lam x t        = Lam (argHiding x) (Abs (unArg x) t)+match (Case n bs) args patch stack =+  case genericSplitAt n args of+    (_, []) -> return $ NoReduction $ NotBlocked $ patch $ map ignoreReduced args+    (args0, MaybeRed red (Arg h r v0) : args1) -> do+      w  <- case red of+              Reduced b  -> return $ fmap (const v0) b+              NotReduced ->+                unfoldCorecursion =<< instantiate v0+      cv <- constructorForm $ ignoreBlocking w+      let v      = ignoreBlocking w+          args'  = args0 ++ [MaybeRed red $ Arg h r v] ++ args1+          stack' = maybe [] (\c -> [(c, args', patch)]) (catchAllBranch bs)+                   ++ stack+          patchLit args = patch (args0 ++ [Arg h r v] ++ args1)+            where (args0, args1) = splitAt n args+          patchCon c m args = patch (args0 ++ [Arg h r $ Con c vs] ++ args1)+            where (args0, args1') = splitAt n args+                  (vs, args1)     = splitAt m args1'+      case w of+        Blocked x _            -> return $ NoReduction $ Blocked x (patch $ map ignoreReduced args')+        NotBlocked (MetaV x _) -> return $ NoReduction $ Blocked x (patch $ map ignoreReduced args')+        NotBlocked (Lit l) -> case Map.lookup l (litBranches bs) of+          Nothing -> match' stack''+          Just cc -> match cc (args0 ++ args1) patchLit stack''+          where+            stack'' = (++ stack') $ case cv of+              Con c vs -> case Map.lookup c (conBranches bs) of+                Nothing -> []+                Just cc -> [(cc, args0 ++ map (MaybeRed red) vs ++ args1, patchCon c (length vs))]+              _        -> []+        NotBlocked (Con c vs) -> case Map.lookup c (conBranches bs) of+          Nothing -> match' stack'+          Just cc -> match cc (args0 ++ map (MaybeRed red) vs ++ args1)+                              (patchCon c (length vs)) stack'+        NotBlocked _ -> return $ NoReduction $ NotBlocked (patch $ map ignoreReduced args')  match' :: Stack -> TCM (Reduced (Blocked Args) Term) match' ((c, args, patch):stack) = match c args patch stack match' [] = typeError $ GenericError "Incomplete pattern matching"  unfoldCorecursion v = case v of-  Def f args -> unfoldDefinition True reduceB (Def f []) f args+  -- Andreas, 2011-10-03 removing DontCare here allow matching on irrelevant things+  DontCare v -> unfoldCorecursion v+  Def f args -> unfoldDefinition True unfoldCorecursion (Def f []) f args   _          -> reduceB v

src/full/Agda/TypeChecking/CompiledClause/Match.hs-boot view

@@ -7,4 +7,3 @@ import Agda.TypeChecking.CompiledClause  matchCompiled :: CompiledClauses -> MaybeReducedArgs -> TCM (Reduced (Blocked Args) Term)-

src/full/Agda/TypeChecking/Constraints.hs view

@@ -11,11 +11,16 @@ import Data.List as List import Data.Set as Set +import Agda.Syntax.Common import Agda.Syntax.Internal+import Agda.Syntax.Scope.Base import Agda.TypeChecking.Monad import Agda.TypeChecking.Errors import Agda.TypeChecking.Pretty import Agda.TypeChecking.Reduce+import Agda.TypeChecking.Substitute+import Agda.TypeChecking.LevelConstraints+import Agda.TypeChecking.MetaVars.Mention  import {-# SOURCE #-} Agda.TypeChecking.Rules.Term (checkExpr) import {-# SOURCE #-} Agda.TypeChecking.Conversion@@ -25,86 +30,138 @@ import Agda.TypeChecking.Free  import Agda.Utils.Fresh+import Agda.Utils.Monad  #include "../undefined.h" import Agda.Utils.Impossible --- | Catch pattern violation errors and adds a constraint.+-- | Catches pattern violation errors and adds a constraint. ---catchConstraint :: MonadTCM tcm => Constraint -> TCM Constraints -> tcm Constraints+catchConstraint :: Constraint -> TCM () -> TCM () catchConstraint c v = liftTCM $    catchError_ v $ \err ->    case errError err of-       PatternErr s -> put s >> buildConstraint c+        -- Not putting s (which should really be the what's already there) makes things go+        -- a lot slower (+20% total time on standard library). How is that possible??+        -- The problem is most likely that there are internal catchErrors which forgets the+        -- state. catchError should preserve the state on pattern violations.+       PatternErr s -> put s >> addConstraint c        _	    -> throwError err --- | Try to solve the constraints to be added.-addNewConstraints :: MonadTCM tcm => Constraints -> tcm ()-addNewConstraints cs = do addConstraints cs; wakeupConstraints+addConstraint :: Constraint -> TCM ()+addConstraint c = do+    pids <- asks envActiveProblems+    reportSDoc "tc.constr.add" 20 $ hsep+      [ text "adding constraint"+      , text (show pids)+      , prettyTCM c ]+    -- Need to reduce to reveal possibly blocking metas+    c <- reduce =<< instantiateFull c+    c' <- simpl c+    if (c /= c')+      then do+        reportSDoc "tc.constr.add" 20 $ text "  simplified:" <+> prettyTCM c'+        solveConstraint_ c'+      else addConstraint' c'+  where+    simpl :: Constraint -> TCM Constraint+    simpl c = do+      n <- genericLength <$> getContext+      let isLvl LevelCmp{} = True+          isLvl _          = False+      cs <- getAllConstraints+      lvls <- instantiateFull $ List.filter (isLvl . clValue . theConstraint) cs+      when (not $ List.null lvls) $ reportSDoc "tc.constr.add" 40 $ text "  simplifying using" <+> prettyTCM lvls+      return $ simplifyLevelConstraint n c lvls  -- | Don't allow the argument to produce any constraints.-noConstraints :: MonadTCM tcm => tcm Constraints -> tcm ()-noConstraints m = do-    cs <- solveConstraints =<< m-    unless (List.null cs) $ typeError $ UnsolvedConstraints cs-    return ()+noConstraints :: TCM a -> TCM a+noConstraints problem = liftTCM $ do+  (pid, x) <- newProblem problem+  cs <- getConstraintsForProblem pid+  unless (List.null cs) $ typeError $ UnsolvedConstraints cs+  return x --- | Guard constraint-guardConstraint :: MonadTCM tcm => tcm Constraints -> Constraint -> tcm Constraints-guardConstraint m c = do-    cs <- solveConstraints =<< m-    case List.partition isNonBlocking cs of-	(scs, []) -> (scs ++) <$> solveConstraint c-	(scs, cs) -> (scs ++) <$> buildConstraint (Guarded c cs)-    where-	isNonBlocking = isNB . clValue-	isNB SortCmp{}        = True-        isNB LevelCmp{}       = True-	isNB ValueCmp{}       = False-        isNB ArgsCmp{}        = False-	isNB TypeCmp{}        = False-	isNB TelCmp{}         = False-	isNB (Guarded c _)    = isNB c-	isNB UnBlock{}        = False-        isNB IsEmpty{}        = False+-- | Create a fresh problem for the given action.+newProblem :: TCM a -> TCM (ProblemId, a)+newProblem action = do+  pid <- fresh+  -- Don't get distracted by other constraints while working on the problem+  x <- nowSolvingConstraints $ solvingProblem pid action+  -- Now we can check any woken constraints+  solveAwakeConstraints+  return (pid, x) --- | We ignore the constraint ids and (as in Agda) retry all constraints every time.---   We probably generate very few constraints.-wakeupConstraints :: MonadTCM tcm => tcm ()-wakeupConstraints = do-    cs <- takeConstraints-    cs <- solveConstraints cs-    addConstraints cs+newProblem_ :: TCM () -> TCM ProblemId+newProblem_ action = fst <$> newProblem action -solveConstraints :: MonadTCM tcm => Constraints -> tcm Constraints-solveConstraints [] = return []-solveConstraints cs = do-    reportSDoc "tc.constr.solve" 60 $-      sep [ text "{ solving", nest 2 $ prettyTCM cs ]-    n  <- length <$> getInstantiatedMetas-    cs0 <- return cs-    cs <- concat <$> mapM (withConstraint solveConstraint) cs-    n' <- length <$> getInstantiatedMetas-    reportSDoc "tc.constr.solve" 70 $-      sep [ text "new constraints", nest 2 $ prettyTCM cs-          , nest 2 $ text $ "progress: " ++ show n' ++ " --> " ++ show n-          ]-    cs <- if (n' > n)-	then solveConstraints cs -- Go again if we made progress-	else return cs-    reportSLn "tc.constr.solve" 60 $ "solved constraints }"-    return cs+ifNoConstraints :: TCM a -> (a -> TCM b) -> (ProblemId -> a -> TCM b) -> TCM b+ifNoConstraints check ifNo ifCs = do+  (pid, x) <- newProblem check+  ifM (isProblemSolved pid) (ifNo x) (ifCs pid x) -solveConstraint :: MonadTCM tcm => Constraint -> tcm Constraints-solveConstraint (ValueCmp cmp a u v) = compareTerm cmp a u v-solveConstraint (ArgsCmp cmp a u v)  = compareArgs cmp a u v-solveConstraint (TypeCmp cmp a b)    = compareType cmp a b-solveConstraint (TelCmp cmp a b)     = compareTel  cmp a b-solveConstraint (SortCmp cmp s1 s2)  = compareSort cmp s1 s2-solveConstraint (LevelCmp cmp a b)   = compareLevel cmp a b-solveConstraint (Guarded c cs)       = guardConstraint (return cs) c-solveConstraint (IsEmpty t)          = isEmptyTypeC t-solveConstraint (UnBlock m)          = do+ifNoConstraints_ :: TCM () -> TCM a -> (ProblemId -> TCM a) -> TCM a+ifNoConstraints_ check ifNo ifCs = ifNoConstraints check (const ifNo) (\pid _ -> ifCs pid)++-- | @guardConstraint cs c@ tries to solve constraints @cs@ first.+--   If successful, it moves on to solve @c@, otherwise it returns+--   a @Guarded c cs@.+guardConstraint :: Constraint -> TCM () -> TCM ()+guardConstraint c blocker =+  ifNoConstraints_ blocker (solveConstraint_ c) (addConstraint . Guarded c)++whenConstraints :: TCM () -> TCM () -> TCM ()+whenConstraints action handler =+  ifNoConstraints_ action (return ()) $ \pid -> do+    stealConstraints pid+    handler++-- | Wake up the constraints depending on the given meta.+wakeupConstraints :: MetaId -> TCM ()+wakeupConstraints x = do+  wakeConstraints (mentionsMeta x)+  solveAwakeConstraints++-- | Wake up all constraints.+wakeupConstraints_ :: TCM ()+wakeupConstraints_ = do+  wakeConstraints (const True)+  solveAwakeConstraints++solveAwakeConstraints :: TCM ()+solveAwakeConstraints = do+    verboseS "profile.constraints" 10 $ liftTCM $ tickMax "max-open-constraints" . genericLength =<< getAllConstraints+    unlessM isSolvingConstraints $ nowSolvingConstraints solve+  where+    solve = do+      reportSDoc "tc.constr.solve" 10 $ hsep [ text "Solving awake constraints."+                                             , text . show . length =<< getAwakeConstraints+                                             , text "remaining." ]+      mc <- takeAwakeConstraint+      flip (maybe $ return ()) mc $ \c -> do+        withConstraint solveConstraint c+        solve++solveConstraint :: Constraint -> TCM ()+solveConstraint c = do+    verboseS "profile.constraints" 10 $ liftTCM $ tick "attempted-constraints"+    verboseBracket "tc.constr.solve" 20 "solving constraint" $ do+      pids <- asks envActiveProblems+      reportSDoc "tc.constr.solve" 20 $ text (show pids) <+> prettyTCM c+      solveConstraint_ c++solveConstraint_ (ValueCmp cmp a u v)       = compareTerm cmp a u v+solveConstraint_ (ElimCmp cmp a e u v)      = compareElims cmp a e u v+solveConstraint_ (TypeCmp cmp a b)          = compareType cmp a b+solveConstraint_ (TelCmp a b cmp tela telb) = compareTel a b cmp tela telb+solveConstraint_ (SortCmp cmp s1 s2)        = compareSort cmp s1 s2+solveConstraint_ (LevelCmp cmp a b)         = compareLevel cmp a b+solveConstraint_ c0@(Guarded c pid)         = do+  ifM (isProblemSolved pid) (solveConstraint_ c)+                            (addConstraint c0)+solveConstraint_ (IsEmpty t)                = isEmptyType t+solveConstraint_ (UnBlock m)                =+  ifM (isFrozen m) (addConstraint $ UnBlock m) $ do     inst <- mvInstantiation <$> lookupMeta m     reportSDoc "tc.constr.unblock" 15 $ text ("unblocking a metavar yields the constraint: " ++ show inst)     case inst of@@ -112,21 +169,100 @@         reportSDoc "tc.constr.blocked" 15 $           text ("blocked const " ++ show m ++ " :=") <+> prettyTCM t         assignTerm m t-        return []       PostponedTypeCheckingProblem cl -> enterClosure cl $ \(e, t, unblock) -> do         b <- liftTCM unblock         if not b-          then buildConstraint $ UnBlock m+          then addConstraint $ UnBlock m           else do             tel <- getContextTelescope             v   <- liftTCM $ checkExpr e t             assignTerm m $ teleLam tel v-            return []       -- Andreas, 2009-02-09, the following were IMPOSSIBLE cases       -- somehow they pop up in the context of sized types       ---      -- already solved metavariables: no constraints left (Ulf, is that correct?)-      InstV{} -> return []-      InstS{} -> return []+      -- already solved metavariables: should only happen for size+      -- metas (not sure why it does, Andreas?)+      InstV{} -> return ()+      InstS{} -> return ()       -- Open (whatever that means)       Open -> __IMPOSSIBLE__+      OpenIFS -> __IMPOSSIBLE__+solveConstraint_ (FindInScope m)      =+  ifM (isFrozen m) (addConstraint $ FindInScope m) $ do+    reportSDoc "tc.constr.findInScope" 15 $ text ("findInScope constraint: " ++ show m)+    mv <- lookupMeta m+    let j = mvJudgement mv+    case j of+      IsSort{} -> __IMPOSSIBLE__+      HasType _ tj -> do+        ctx <- getContextVars+        ctxArgs <- getContextArgs+        t <- normalise $ tj `piApply` ctxArgs+        reportSLn "tc.constr.findInScope" 15 $ "findInScope t: " ++ show t+        let candsP1 = [(term, t) | (term, t, Instance) <- ctx]+        let candsP2 = [(term, t) | (term, t, h) <- ctx, h /= Instance]+        let scopeInfo = getMetaScope mv+        let ns = everythingInScope scopeInfo+        let nsList = Map.toList $ nsNames ns+        -- try all abstract names in scope (even ones that you can't refer to+        --  unambiguously)+        let candsP3Names = nsList >>= snd+        candsP3Types <- mapM (typeOfConst . anameName) candsP3Names+        candsP3FV <- mapM (freeVarsToApply . anameName) candsP3Names+        let candsP3 = [(Def (anameName an) vs, t) |+                       (an, t, vs) <- zip3 candsP3Names candsP3Types candsP3FV]+        let cands = [candsP1, candsP2, candsP3]+        cands <- mapM (filterM (uncurry $ checkCandidateForMeta m t )) cands+        let iterCands :: [(Int, [(Term, Type)])] -> TCM ()+            iterCands [] = do reportSDoc "tc.constr.findInScope" 15 $ text "not a single candidate found..."+                              typeError $ IFSNoCandidateInScope t+            iterCands ((p, []) : cs) = do reportSDoc "tc.constr.findInScope" 15 $ text $+                                            "no candidates found at p=" ++ show p ++ ", trying next p..."+                                          iterCands cs+            iterCands ((p, [(term, t')]):_) =+              do reportSDoc "tc.constr.findInScope" 15 $ text (+                   "one candidate at p=" ++ show p ++ " found for type '") <+>+                   prettyTCM t <+> text "': '" <+> prettyTCM term <+>+                   text "', of type '" <+> prettyTCM t' <+> text "'."+                 leqType t t'+                 assignV m ctxArgs term+            iterCands ((p, cs):_) = do reportSDoc "tc.constr.findInScope" 15 $+                                         text ("still more than one candidate at p=" ++ show p ++ ": ") <+>+                                         prettyTCM (List.map fst cs)+                                       addConstraint $ FindInScope m+        iterCands [(1,concat cands)]+      where+        getContextVars :: TCM [(Term, Type, Hiding)]+        getContextVars = do+          ctx <- getContext+          let ids = [0.. fromIntegral (length ctx) - 1] :: [Nat]+          types <- mapM typeOfBV ids+          return $ [ (Var i [], t, h) | (Arg h _ _, i, t) <- zip3 ctx [0..] types ]+        checkCandidateForMeta :: MetaId -> Type -> Term -> Type -> TCM Bool+        checkCandidateForMeta m t term t' =+          liftTCM $ flip catchError (\err -> return False) $ do+            reportSLn "tc.constr.findInScope" 20 $ "checkCandidateForMeta\n  t: " ++ show t ++ "\n  t':" ++ show t' ++ "\n  term: " ++ show term ++ "."+            localState $ do+               -- domi: we assume that nothing below performs direct IO (except+               -- for logging and such, I guess)+               leqType t t'+               tel <- getContextTelescope+               assignTerm m (teleLam tel term)+               -- make a pass over constraints, to detect cases where some are made+               -- unsolvable by the assignment, but don't do this for FindInScope's+               -- to prevent loops. We currently also ignore UnBlock constraints+               -- to be on the safe side.+               wakeConstraints (isSimpleConstraint . clValue . theConstraint)+               solveAwakeConstraints+            return True+        isSimpleConstraint :: Constraint -> Bool+        isSimpleConstraint FindInScope{} = False+        isSimpleConstraint UnBlock{}     = False+        isSimpleConstraint _             = True++localState :: MonadState s m => m a -> m a+localState m = do+  s <- get+  x <- m+  put s+  return x

src/full/Agda/TypeChecking/Conversion.hs view

@@ -15,6 +15,7 @@ import Agda.Syntax.Internal import Agda.TypeChecking.Monad import Agda.TypeChecking.MetaVars+import Agda.TypeChecking.MetaVars.Occurs (killArgs,PruneResult(..)) import Agda.TypeChecking.Substitute import Agda.TypeChecking.Reduce import Agda.TypeChecking.Constraints@@ -27,8 +28,10 @@ import Agda.TypeChecking.SizedTypes import Agda.TypeChecking.Monad.Builtin import Agda.TypeChecking.Level+import Agda.TypeChecking.Irrelevance import Agda.TypeChecking.EtaContract-import Agda.TypeChecking.UniversePolymorphism+import Agda.TypeChecking.Eliminators+-- import Agda.TypeChecking.UniversePolymorphism  import Agda.Utils.Monad @@ -37,6 +40,9 @@ #include "../undefined.h" import Agda.Utils.Impossible +mlevel :: TCM (Maybe Term)+mlevel = liftTCM $ (Just <$> primLevel) `catchError` \_ -> return Nothing+ nextPolarity []       = (Invariant, []) nextPolarity (p : ps) = (p, ps) @@ -48,43 +54,76 @@ 	same (Arg _ _ (Var n [])) (Arg _ _ (Var m [])) = n == m 	same _ _				       = False -equalTerm :: MonadTCM tcm => Type -> Term -> Term -> tcm Constraints+-- | @intersectVars us vs@ checks whether all relevant elements in @us@ and @vs@+--   are variables, and if yes, returns a prune list which says @True@ for+--   arguments which are different and can be pruned.+intersectVars :: Args -> Args -> Maybe [Bool]+intersectVars = zipWithM areVars where+    -- ignore irrelevant args+    areVars u v | argRelevance u == Irrelevant        = Just False -- do not prune+    areVars (Arg _ _ (Var n [])) (Arg _ _ (Var m [])) = Just $ n /= m -- prune different vars+    areVars _ _                                       = Nothing++equalTerm :: Type -> Term -> Term -> TCM () equalTerm = compareTerm CmpEq -equalAtom :: MonadTCM tcm => Type -> Term -> Term -> tcm Constraints+equalAtom :: Type -> Term -> Term -> TCM () equalAtom = compareAtom CmpEq -equalArgs :: MonadTCM tcm => Type -> Args -> Args -> tcm Constraints-equalArgs = compareArgs []--equalType :: MonadTCM tcm => Type -> Type -> tcm Constraints+equalType :: Type -> Type -> TCM () equalType = compareType CmpEq  -- | Type directed equality on values. ---compareTerm :: MonadTCM tcm => Comparison -> Type -> Term -> Term -> tcm Constraints-compareTerm cmp a m n =-  verboseBracket "tc.conv.term" 5 "compareTerm" $-  catchConstraint (ValueCmp cmp a m n) $ do-    a'       <- reduce a-    reportSDoc "tc.conv.term" 10 $ fsep+compareTerm :: Comparison -> Type -> Term -> Term -> TCM ()+  -- If one term is a meta, try to instantiate right away. This avoids unnecessary unfolding.+compareTerm cmp a u v = liftTCM $ do+  (u, v) <- instantiate (u, v)+  reportSDoc "tc.conv.term" 10 $ sep [ text "compareTerm"+                                     , nest 2 $ prettyTCM u <+> prettyTCM cmp <+> prettyTCM v+                                     , nest 2 $ text ":" <+> prettyTCM a ]+  let fallback = compareTerm' cmp a u v+  case (u, v) of+    (u@(MetaV x us), v@(MetaV y vs))+      | x /= y    -> solve1 `orelse` solve2 `orelse` compareTerm' cmp a u v+      | otherwise -> fallback+      where+        (solve1, solve2) | x > y     = (assign x us v, assign y vs u)+                         | otherwise = (assign y vs u, assign x us v)+    (u@(MetaV x us), v) -> assign x us v `orelse` fallback+    (u, v@(MetaV y vs)) -> assign y vs u `orelse` fallback+    _                   -> fallback+  where+    assign x us v = do+      reportSDoc "tc.conv.term" 20 $ sep [ text "attempting shortcut"+                                         , nest 2 $ prettyTCM (MetaV x us) <+> text ":=" <+> prettyTCM v ]+      ifM (isInstantiatedMeta x) patternViolation (assignV x us v)+    -- Should be ok with catchError_ but catchError is much safer since we don't+    -- rethrow errors.+    m `orelse` h = m `catchError` \err -> case errError err of+                    PatternErr s -> put s >> h+                    _            -> h++compareTerm' :: Comparison -> Type -> Term -> Term -> TCM ()+compareTerm' cmp a m n =+  verboseBracket "tc.conv.term" 20 "compareTerm" $ do+  a' <- reduce a+  catchConstraint (ValueCmp cmp a' m n) $ do+    reportSDoc "tc.conv.term" 30 $ fsep       [ text "compareTerm", prettyTCM m, prettyTCM cmp, prettyTCM n, text ":", prettyTCM a' ]     proofIrr <- proofIrrelevance     isSize   <- isSizeType a'     s        <- reduce $ getSort a'     mlvl     <- mlevel     case s of-      Prop | proofIrr -> return []+      Prop | proofIrr -> return ()       _    | isSize   -> compareSizes cmp m n       _               -> case unEl a' of-        a | Just a == mlvl -> equalLevel m n+        a | Just a == mlvl -> do+          a <- levelView m+          b <- levelView n+          equalLevel a b         Pi a _    -> equalFun (a,a') m n-        Fun a _   -> equalFun (a,a') m n-        MetaV x _ -> do-          (m,n) <- normalise (m,n)-          if m == n-            then return []-            else buildConstraint (ValueCmp cmp a m n)         Lam _ _   -> __IMPOSSIBLE__         Def r ps  -> do           isrec <- isEtaRecord r@@ -93,13 +132,25 @@               m <- reduceB m               n <- reduceB n               case (m, n) of-                _ | isMeta m || isMeta n || (isNeutral m && isNeutral n) ->+                _ | isMeta m || isMeta n ->                     compareAtom cmp a' (ignoreBlocking m) (ignoreBlocking n)++                _ | isNeutral m && isNeutral n -> do+                    -- Andreas 2011-03-23: (fixing issue 396)+                    -- if we are dealing with a singleton record,+                    -- we can succeed immediately+                    isSing <- isSingletonRecordModuloRelevance r ps+                    case isSing of+                      Right True -> return ()+                      -- do not eta-expand if comparing two neutrals+                      _ -> compareAtom cmp a' (ignoreBlocking m) (ignoreBlocking n)                 _ -> do                   (tel, m') <- etaExpandRecord r ps $ ignoreBlocking m                   (_  , n') <- etaExpandRecord r ps $ ignoreBlocking n                   -- No subtyping on record terms-                  compareArgs [] (telePi_ tel $ sort Prop) m' n'+                  c <- getRecordConstructor r+                  compareArgs [] (telePi_ tel $ sort Prop) (Con c []) m' n'+             else compareAtom cmp a' m n         _ -> compareAtom cmp a' m n   where@@ -118,163 +169,194 @@         p	= fmap (const $ Var 0 []) a         (m',n') = raise 1 (m,n) `apply` [p]         t'	= raise 1 t `piApply` [p]-        suggest (Fun _ _)	 = "x"-        suggest (Pi _ (Abs x _)) = x-        suggest _		 = __IMPOSSIBLE__+        suggest (Pi _ b) = absName b+        suggest _	 = __IMPOSSIBLE__ -compareTel :: MonadTCM tcm => Comparison -> Telescope -> Telescope -> tcm Constraints-compareTel cmp tel1 tel2 =-  verboseBracket "tc.conv.tel" 5 "compareTel" $-  catchConstraint (TelCmp cmp tel1 tel2) $ case (tel1, tel2) of-    (EmptyTel, EmptyTel) -> return []+-- | @compareTel t1 t2 cmp tel1 tel1@ checks whether pointwise @tel1 `cmp` tel2@+--   and complains that @t2 `cmp` t1@ failed if not.+compareTel :: Type -> Type ->+  Comparison -> Telescope -> Telescope -> TCM ()+compareTel t1 t2 cmp tel1 tel2 =+  verboseBracket "tc.conv.tel" 20 "compareTel" $+  catchConstraint (TelCmp t1 t2 cmp tel1 tel2) $ case (tel1, tel2) of+    (EmptyTel, EmptyTel) -> return ()     (EmptyTel, _)        -> bad     (_, EmptyTel)        -> bad     (ExtendTel arg1@(Arg h1 r1 a1) tel1, ExtendTel arg2@(Arg h2 r2 a2) tel2)       | h1 /= h2 -> bad+        -- Andreas, 2011-09-11 do not test r1 == r2 because they could differ+        -- e.g. one could be Forced and the other Relevant (see fail/UncurryMeta)       | otherwise -> do           let (tel1', tel2') = raise 1 (tel1, tel2)               arg            = Var 0 []           name <- freshName_ (suggest (absName tel1) (absName tel2))-          cs   <- compareType cmp a1 a2-          let c = TelCmp cmp (absApp tel1' arg) (absApp tel2' arg)--	  let dependent = 0 `freeIn` absBody tel2--          if dependent-	    then addCtx name arg1 $ guardConstraint (return cs) c-	    else do cs' <- addCtx name arg1 $ solveConstraint c-		    return $ cs ++ cs'+          let checkArg = escapeContext 1 $ compareType cmp a1 a2+          let c = TelCmp t1 t2 cmp (absApp tel1' arg) (absApp tel2' arg)+          let r = max r1 r2  -- take "most irrelevant"+              dependent = (r /= Irrelevant) && isBinderUsed tel2+          addCtx name arg1 $+            if dependent+	    then guardConstraint c checkArg+	    else checkArg >> solveConstraint_ c           where             suggest "_" y = y             suggest  x  _ = x   where-    bad = typeError $ UnequalTelescopes cmp tel1 tel2+    -- Andreas, 2011-05-10 better report message about types+    bad = typeError $ UnequalTypes cmp t2 t1 -- switch t2 and t1 because of contravariance!+--    bad = typeError $ UnequalTelescopes cmp tel1 tel2  -- | Syntax directed equality on atomic values ---compareAtom :: MonadTCM tcm => Comparison -> Type -> Term -> Term -> tcm Constraints+compareAtom :: Comparison -> Type -> Term -> Term -> TCM () compareAtom cmp t m n =-    verboseBracket "tc.conv.atom" 5 "compareAtom" $+    verboseBracket "tc.conv.atom" 20 "compareAtom" $+    -- if a PatternErr is thrown, rebuild constraint!     catchConstraint (ValueCmp cmp t m n) $ do+      let unLevel (Level l) = reallyUnLevelView l+          unLevel v = return v       -- constructorForm changes literal to constructors       -- Andreas: what happens if I cut out the eta expansion here?       -- Answer: Triggers issue 245, does not resolve 348-      mb <- traverse constructorForm =<< etaExpandBlocked =<< reduceB m-      nb <- traverse constructorForm =<< etaExpandBlocked =<< reduceB n+      mb <- traverse unLevel =<< traverse constructorForm =<< etaExpandBlocked =<< reduceB m+      nb <- traverse unLevel =<< traverse constructorForm =<< etaExpandBlocked =<< reduceB n+       let m = ignoreBlocking mb           n = ignoreBlocking nb-      reportSDoc "tc.conv.atom" 10 $ fsep-	[ text "compareAtom", prettyTCM mb, prettyTCM cmp, prettyTCM nb, text ":", prettyTCM t ]++          postpone = addConstraint $ ValueCmp cmp t m n++          checkSyntacticEquality = do+            n <- normalise n    -- is this what we want?+            m <- normalise m+            if m == n+                then return ()	-- Check syntactic equality for blocked terms+                else postpone++      reportSDoc "tc.conv.atom" 30 $+	text "compareAtom" <+> fsep [ prettyTCM mb <+> prettyTCM cmp+                                    , prettyTCM nb+                                    , text ":" <+> prettyTCM t ]       case (mb, nb) of+        -- equate two metas x and y.  if y is the younger meta,+        -- try first y := x and then x := y         (NotBlocked (MetaV x xArgs), NotBlocked (MetaV y yArgs))-            | x == y -> if   sameVars xArgs yArgs-                        then return []-                        else do -- Check syntactic equality on meta-variables+            | x == y ->+              case intersectVars xArgs yArgs of+                -- all relevant arguments are variables+                Just kills -> do+                  -- kills is a list with 'True' for each different var+                  killResult <- killArgs kills x+                  case killResult of+                    NothingToPrune   -> return ()+                    PrunedEverything -> return ()+                    PrunedNothing    -> postpone+                    PrunedSomething  -> postpone+                    -- OLD CODE: if killedAll then return () else checkSyntacticEquality+                -- not all relevant arguments are variables+                Nothing -> checkSyntacticEquality -- Check syntactic equality on meta-variables                                 -- (same as for blocked terms)-                          m <- normalise m-                          n <- normalise n-                          if m == n-                            then return []-                            else buildConstraint (ValueCmp cmp t m n)             | otherwise -> do                 [p1, p2] <- mapM getMetaPriority [x,y]                 -- instantiate later meta variables first                 let (solve1, solve2)                       | (p1,x) > (p2,y) = (l,r)                       | otherwise	    = (r,l)-                      where l = assignV t x xArgs n-                            r = assignV t y yArgs m-                    try m fallback = do-                      cs <- m-                      case cs of-                        []	-> return []-                        _	-> fallback cs+                      where l = assignV x xArgs n+                            r = assignV y yArgs m +                    try m h = m `catchError_` \err -> case errError err of+                      PatternErr s -> put s >> h+                      _            -> throwError err+                 -- First try the one with the highest priority. If that doesn't-                -- work, try the low priority one. If that doesn't work either,-                -- go with the first version.-                rollback <- return . put =<< get-                try solve1 $ \cs -> do-                  undoRollback <- return . put =<< get-                  rollback-                  try solve2 $ \_ -> do-                    undoRollback-                    return cs+                -- work, try the low priority one.+                try solve1 solve2 -	(NotBlocked (MetaV x xArgs), _) -> assignV t x xArgs n-	(_, NotBlocked (MetaV x xArgs)) -> assignV t x xArgs m-        (Blocked{}, Blocked{})	-> do-            n <- normalise n    -- is this what we want?-            m <- normalise m-            if m == n-                then return []	-- Check syntactic equality for blocked terms-                else buildConstraint $ ValueCmp cmp t m n+        -- one side a meta, the other an unblocked term+	(NotBlocked (MetaV x xArgs), _) -> assignV x xArgs n+	(_, NotBlocked (MetaV x xArgs)) -> assignV x xArgs m++        (Blocked{}, Blocked{})	-> checkSyntacticEquality         (Blocked{}, _)    -> useInjectivity cmp t m n         (_,Blocked{})     -> useInjectivity cmp t m n         _ -> case (m, n) of-	    _ | f1@(FunV _ _) <- funView m-	      , f2@(FunV _ _) <- funView n -> equalFun f1 f2+	    (Pi{}, Pi{}) -> equalFun m n  	    (Sort s1, Sort s2) -> compareSort CmpEq s1 s2 -	    (Lit l1, Lit l2) | l1 == l2 -> return []+	    (Lit l1, Lit l2) | l1 == l2 -> return () 	    (Var i iArgs, Var j jArgs) | i == j -> do 		a <- typeOfBV i                 -- Variables are invariant in their arguments-		compareArgs [] a iArgs jArgs-	    (Def x xArgs, Def y yArgs) | x == y -> do-                pol <- getPolarity' cmp x-		reportSDoc "tc.conv.atom" 20 $-		  text "compareArgs" <+> sep-                    [ sep [ prettyTCM xArgs-			  , prettyTCM yArgs-			  ]-                    , nest 2 $ text (show pol)-                    ]-		a <- defType <$> getConstInfo x-		compareArgs pol a xArgs yArgs+		compareArgs [] a (Var i []) iArgs jArgs+            (Def{}, Def{}) -> do+              ev1 <- elimView m+              ev2 <- elimView n+              case (ev1, ev2) of+                (VarElim x els1, VarElim y els2) | x == y -> cmpElim (typeOfBV x) (Var x []) els1 els2+                (ConElim x els1, ConElim y els2) | x == y -> cmpElim (conType x t) (Con x []) els1 els2+                (DefElim x els1, DefElim y els2) | x == y ->+                  cmpElim (defType <$> getConstInfo x) (Def x []) els1 els2+                (MetaElim{}, _) -> __IMPOSSIBLE__   -- projections from metas should have been eta expanded+                (_, MetaElim{}) -> __IMPOSSIBLE__+                _ -> typeError $ UnequalTerms cmp m n t+                where+                  polarities (Def x _) = getPolarity' cmp x+                  polarities _         = return []+                  cmpElim t v els1 els2 = do+                    a   <- t+                    pol <- polarities v+                    reportSDoc "tc.conv.elim" 10 $+                      text "compareElim" <+> vcat+                        [ text "a    =" <+> prettyTCM a+                        , text "v    =" <+> prettyTCM v+                        , text "els1 =" <+> prettyTCM els1+                        , text "els2 =" <+> prettyTCM els2+                        ]+                    compareElims pol a v els1 els2 	    (Con x xArgs, Con y yArgs) 		| x == y -> do-		    -- The type is a datatype or a record.-		    Def d args <- reduce $ unEl t-		    -- Get the number of parameters to the datatype (or record)-                    npars <- do-                      def <- theDef <$> getConstInfo d-                      case def of-		        Datatype{dataPars = npars} -> return npars-                        Record{recPars = npars}    -> return npars-                        _                          -> __IMPOSSIBLE__-		    -- The type to compare the arguments at is obtained by-		    -- instantiating the parameters.-		    a <- defType <$> getConstInfo x-		    let a' = piApply a (genericTake npars args)+                    -- Get the type of the constructor instantiated to the datatype parameters.+                    a' <- conType x t                     -- Constructors are invariant in their arguments                     -- (could be covariant).-                    compareArgs [] a' xArgs yArgs+                    compareArgs [] a' (Con x []) xArgs yArgs             _ -> typeError $ UnequalTerms cmp m n t     where-	equalFun (FunV arg1@(Arg h1 r1 a1) t1) (FunV (Arg h2 r2 a2) t2)+        conType c (El _ (Def d args)) = do+          npars <- do+            def <- theDef <$> getConstInfo d+            return $ case def of Datatype{dataPars = n} -> n+                                 Record{recPars = n}    -> n+                                 _                      -> __IMPOSSIBLE__+          a <- defType <$> getConstInfo c+          return $ piApply a (genericTake npars args)+        conType _ _ = __IMPOSSIBLE__++	equalFun t1@(Pi arg1@(Arg h1 r1 a1) _) t2@(Pi (Arg h2 r2 a2) _) 	    | h1 /= h2	= typeError $ UnequalHiding ty1 ty2             -- Andreas 2010-09-21 compare r1 and r2, but ignore forcing annotations! 	    | ignoreForced r1 /= ignoreForced r2 = typeError $ UnequalRelevance ty1 ty2-	    | otherwise = do-		    let (ty1',ty2') = raise 1 (ty1,ty2)-			arg	    = Arg h1 r1 (Var 0 [])-		    name <- freshName_ (suggest t1 t2)-		    cs   <- compareType cmp a2 a1-		    let c = TypeCmp cmp (piApply ty1' [arg]) (piApply ty2' [arg])+	    | otherwise = verboseBracket "tc.conv.fun" 15 "compare function types" $ do+                reportSDoc "tc.conv.fun" 20 $ nest 2 $ vcat+                  [ text "t1 =" <+> prettyTCM t1+                  , text "t2 =" <+> prettyTCM t2 ]+                let (ty1',ty2') = raise 1 (ty1,ty2)+                    arg	    = Arg h1 r1 (Var 0 [])+                name <- freshName_ (suggest t1 t2)+                let checkArg = escapeContext 1 $ compareType cmp a2 a1+                    c        = TypeCmp cmp (piApply ty1' [arg]) (piApply ty2' [arg]) -		    -- We only need to require a1 == a2 if t2 is a dependent function type.-		    -- If it's non-dependent it doesn't matter what we add to the context.-		    let dependent = case t2 of-					Pi _ _	-> True-					Fun _ _	-> False-					_	-> __IMPOSSIBLE__-		    if dependent-			then addCtx name arg1 $ guardConstraint (return cs) c-			else do-			    cs' <- addCtx name arg1 $ solveConstraint c-			    return $ cs ++ cs'+                -- We only need to require a1 == a2 if t2 is a dependent function type.+                -- If it's non-dependent it doesn't matter what we add to the context.+                let dependent = case t2 of+                                    Pi _ b  -> isBinderUsed b+                                    _       -> __IMPOSSIBLE__+                addCtx name arg1 $+                  if dependent+                  then guardConstraint c checkArg+                  else checkArg >> solveConstraint_ c 	    where 		ty1 = El (getSort a1) t1    -- TODO: wrong (but it doesn't matter) 		ty2 = El (getSort a2) t2@@ -282,92 +364,95 @@ 				    []	-> "_" 				    x:_	-> x 		    where-			name (Pi _ (Abs x _)) = [x]-			name (Fun _ _)	      = []-			name _		      = __IMPOSSIBLE__+			name (Pi _ b) = filter (/= "_") [absName b]+			name _        = __IMPOSSIBLE__ 	equalFun _ _ = __IMPOSSIBLE__ +-- | Type-directed equality on eliminator spines+compareElims :: [Polarity] -> Type -> Term -> [Elim] -> [Elim] -> TCM ()+compareElims _ _ _ [] [] = return ()+compareElims _ _ _ [] (_:_) = __IMPOSSIBLE__+compareElims _ _ _ (_:_) [] = __IMPOSSIBLE__+compareElims _ _ _ (Apply{} : _) (Proj{} : _) = __IMPOSSIBLE__+compareElims _ _ _ (Proj{} : _) (Apply{} : _) = __IMPOSSIBLE__+compareElims pols0 a v els01@(Apply arg1 : els1) els02@(Apply arg2 : els2) =+  verboseBracket "tc.conv.elim" 20 "compare Apply" $ do+  reportSDoc "tc.conv.elim" 25 $ nest 2 $ vcat+    [ text "a    =" <+> prettyTCM a+    , text "v    =" <+> prettyTCM v+    , text "els1 =" <+> prettyTCM els01+    , text "els2 =" <+> prettyTCM els02+    ]+  let (pol, pols) = nextPolarity pols0+  ab <- reduceB a+  let a = ignoreBlocking ab+  catchConstraint (ElimCmp pols0 a v els01 els02) $ do+  case unEl <$> ab of+    Blocked{}                     -> patternViolation+    NotBlocked MetaV{}            -> patternViolation+    NotBlocked (Pi (Arg _ r b) _) -> do+      let cmp x y = case pol of+                      Invariant     -> compareTerm CmpEq  b x y+                      Covariant     -> compareTerm CmpLeq b x y+                      Contravariant -> compareTerm CmpLeq b y x+      mlvl <- mlevel+      let checkArg = case r of+            Forced     -> return ()+            Irrelevant -> return () -- Andreas: ignore irr. func. args.+            _          -> applyRelevanceToContext r $+                            cmp (unArg arg1) (unArg arg2)+          dependent = case unEl a of+            Pi (Arg _ _ (El _ lvl')) c -> 0 `freeInIgnoringSorts` absBody c+                                          && Just lvl' /= mlvl+            _ -> False +          theRest = ElimCmp pols (piApply a [arg1]) (apply v [arg1]) els1 els2 +      if dependent+        then guardConstraint theRest checkArg+        else checkArg >> solveConstraint_ theRest++    _ -> __IMPOSSIBLE__+compareElims pols a v els01@(Proj f : els1) els02@(Proj f' : els2)+  | f /= f'   = typeError . GenericError . show =<< prettyTCM f <+> text "/=" <+> prettyTCM f'+  | otherwise = do+    a <- reduce a+    case unEl a of+      Def r us -> do+        let (pol, _) = nextPolarity pols+        ft <- defType <$> getConstInfo f+        let arg = Arg NotHidden Relevant v  -- TODO: not necessarily relevant?+        let c = piApply ft (us ++ [arg])+        (cmp, els1, els2) <- return $ case pol of+              Invariant     -> (CmpEq, els1, els2)+              Covariant     -> (CmpLeq, els1, els2)+              Contravariant -> (CmpLeq, els2, els2)+        pols' <- getPolarity' cmp f+        compareElims pols' c (Def f [arg]) els1 els2+      _ -> __IMPOSSIBLE__+ -- | Type-directed equality on argument lists ---compareArgs :: MonadTCM tcm => [Polarity] -> Type -> Args -> Args -> tcm Constraints-compareArgs _ _ [] [] = return []-compareArgs _ _ [] (_:_) = __IMPOSSIBLE__-compareArgs _ _ (_:_) [] = __IMPOSSIBLE__-compareArgs pols0 a (arg1 : args1) (arg2 : args2) =-    verboseBracket "tc.conv.args" 5 "compareArgs" $ do-    let (pol, pols) = nextPolarity pols0-    a <- reduce a-    catchConstraint (ArgsCmp pols0 a (arg1 : args1) (arg2 : args2)) $ do-    reportSDoc "tc.conv.args" 30 $-      sep [ text "compareArgs"-          , nest 2 $ sep [ prettyTCM (arg1 : args1)-                         , prettyTCM (arg2 : args2)-                         ]-          , nest 2 $ text ":" <+> prettyTCM a-          ]-    case funView (unEl a) of-	FunV (Arg _ r b) _ -> do-	    reportSDoc "tc.conv.args" 10 $-              sep [ text "compareArgs" <+> parens (text $ show pol ++ " " ++ show r)-                  , nest 2 $ sep [ prettyTCM arg1-                                 , text "~~" <+> prettyTCM arg2-                                 , text ":" <+> prettyTCM b-                                 ]-                  ]-            let cmp x y = case pol of-                            Invariant     -> compareTerm CmpEq b x y-                            Covariant     -> compareTerm CmpLeq b x y-                            Contravariant -> compareTerm CmpLeq b y x-            cs1 <- case r of-                    Forced     -> return []-                    Irrelevant -> return [] -- Andreas: ignore irr. func. args.-                    Relevant   -> cmp (unArg arg1) (unArg arg2)-            -- mlvl <- mlevel-	    case (cs1, unEl a) of-                                -- We can safely ignore sort annotations here-                                -- (except it's not, we risk leaving unsolved sorts)-                                -- We're also ignoring levels which isn't quite as-                                -- safe (it would be if we disallowed matching on levels?)-		(_:_, Pi (Arg _ _ (El _ lvl')) c) | 0 `freeInIgnoringSorts` absBody c-                                                  -- && Just lvl' /= mlvl-		    -> do-                        reportSDoc "tc.conv.args" 15 $ sep-                          [ text "aborting compareArgs" <+> parens (text $ show pol)-                          , nest 2 $ fsep-                              [ prettyTCM arg1-                              , text "~~" <+> prettyTCM arg2-                              , text ":" <+> prettyTCM b-                              , text "--->" <+> prettyTCM cs1-                              ]-                          ]-                        patternViolation-		_   -> do-                    reportSDoc "tc.conv.args" 15 $ sep-                      [ text "compareArgs" <+> parens (text $ show pol)-                      , nest 2 $ sep-                        [ prettyTCM args1-                        , text "~~" <+> prettyTCM args2-                        , text ":" <+> prettyTCM (piApply a [arg1])-                        ]-                      ]-		    cs2 <- compareArgs pols (piApply a [arg1]) args1 args2-		    return $ cs1 ++ cs2-        _   -> patternViolation+compareArgs :: [Polarity] -> Type -> Term -> Args -> Args -> TCM ()+compareArgs pol a v args1 args2 =+  compareElims pol a v (map Apply args1) (map Apply args2)  -- | Equality on Types-compareType :: MonadTCM tcm => Comparison -> Type -> Type -> tcm Constraints+compareType :: Comparison -> Type -> Type -> TCM () compareType cmp ty1@(El s1 a1) ty2@(El s2 a2) =-    verboseBracket "tc.conv.type" 5 "compareType" $+    verboseBracket "tc.conv.type" 20 "compareType" $     catchConstraint (TypeCmp cmp ty1 ty2) $ do-	reportSDoc "tc.conv.type" 9 $ vcat-          [ hsep [ text "compareType", prettyTCM ty1, prettyTCM cmp, prettyTCM ty2 ]+	reportSDoc "tc.conv.type" 50 $ vcat+          [ text "compareType" <+> sep [ prettyTCM ty1 <+> prettyTCM cmp+                                       , prettyTCM ty2 ]           , hsep [ text "   sorts:", prettyTCM s1, text " and ", prettyTCM s2 ]           ]-	cs1 <- compareSort CmpEq s1 s2 `catchError` \err -> case errError err of+-- Andreas, 2011-4-27 should not compare sorts, but currently this is needed+-- for solving sort and level metas+--        let cs1 = []+	compareSort CmpEq s1 s2 `catchError` \err -> case errError err of                   TypeError _ _ -> do-                    reportSDoc "tc.conv.type" 10 $ vcat+                    reportSDoc "tc.conv.type" 30 $ vcat                       [ text "sort comparison failed"                       , nest 2 $ vcat                         [ text "s1 =" <+> prettyTCM s1@@ -379,169 +464,189 @@                     -- Throw the original error if the above doesn't                     -- give an error (for instance, due to pending                     -- constraints).+                    -- Or just ignore it... We run into this with irrelevant levels+                    -- which may show up in sort constraints, causing them to fail.+                    -- In any case it's not safe to ignore the error, for instance+                    -- a1 might be Set and a2 a meta of type Set, in which case we+                    -- really need the sort comparison to fail, instead of silently+                    -- instantiating the meta.                     throwError err                   _             -> throwError err-	cs2 <- compareTerm cmp (sort s1) a1 a2-        cs  <- solveConstraints $ cs1 ++ cs2-        unless (null cs) $-          reportSDoc "tc.conv.type" 9 $-            text "   --> " <+> prettyTCM cs-	return cs+	compareTerm cmp (sort s1) a1 a2+	return () -leqType :: MonadTCM tcm => Type -> Type -> tcm Constraints+leqType :: Type -> Type -> TCM () leqType = compareType CmpLeq  --------------------------------------------------------------------------- -- * Sorts --------------------------------------------------------------------------- -compareSort :: MonadTCM tcm => Comparison -> Sort -> Sort -> tcm Constraints+compareSort :: Comparison -> Sort -> Sort -> TCM () compareSort CmpEq  = equalSort-compareSort CmpLeq = leqSort-  -- TODO: change to leqSort when we have better constraint solving-  --       or not? might not be needed if we get universe polymorphism-  --       leqSort is still used when checking datatype declarations though+compareSort CmpLeq = equalSort  -- | Check that the first sort is less or equal to the second.-leqSort :: MonadTCM tcm => Sort -> Sort -> tcm Constraints+leqSort :: Sort -> Sort -> TCM () leqSort s1 s2 =-  ifM typeInType (return []) $+  ifM typeInType (return ()) $     catchConstraint (SortCmp CmpLeq s1 s2) $     do	(s1,s2) <- reduce (s1,s2)-        reportSDoc "tc.conv.sort" 10 $+        reportSDoc "tc.conv.sort" 30 $           sep [ text "leqSort"               , nest 2 $ fsep [ prettyTCM s1 <+> text "=<"                               , prettyTCM s2 ]               ] 	case (s1,s2) of -            -- New universe polymorphism---             (Type a  , Type b  )             -> compareLevel CmpLeq a b--	    (Type (Lit (LitLevel _ n)), Type (Lit (LitLevel _ m)))-              | n <= m    -> return []-	      | otherwise -> notLeq s1 s2             (Type a, Type b) -> leqLevel a b -	    (Prop    , Prop    )	     -> return []+	    (Prop    , Prop    )	     -> return () 	    (Type _  , Prop    )	     -> notLeq s1 s2-	    (Suc _   , Prop    )	     -> notLeq s1 s2 -	    (Prop    , Type _  )	     -> return []--	    (Suc s   , Type (Lit (LitLevel _ n)))-              | 1 <= n    -> leqSort s (mkType $ n - 1)-	    (Suc s   , Type b  ) -> notLeq s1 s2  -- TODO-            (Suc s1  , Suc s2  ) -> leqSort s1 s2 -- TODO: not what we want for Prop(?)-	    (_	     , Suc _   )	     -> equalSort s1 s2--	    (Lub a b , _       )	     -> liftM2 (++) (leqSort a s2) (leqSort b s2)-	    (_	     , Lub _ _ )	     -> equalSort s1 s2+	    (Prop    , Type _  )	     -> return () -	    (MetaS{} , _       )	     -> equalSort s1 s2-	    (_	     , MetaS{} )	     -> equalSort s1 s2-            (Inf     , Inf     )             -> return []-            (Inf     , _       )             -> notLeq s1 s2-            (_       , Inf     )             -> return []+            (_       , Inf     )             -> return ()+            (Inf     , _       )             -> equalSort s1 s2             (DLub{}  , _       )             -> equalSort s1 s2             (_       , DLub{}  )             -> equalSort s1 s2     where 	notLeq s1 s2 = typeError $ NotLeqSort s1 s2 -leqLevel :: MonadTCM tcm => Term -> Term -> tcm Constraints+leqLevel :: Level -> Level -> TCM () leqLevel a b = liftTCM $ do-  reportSDoc "tc.conv.nat" 10 $+  reportSDoc "tc.conv.nat" 30 $     text "compareLevel" <+>       sep [ prettyTCM a <+> text "=<"           , prettyTCM b ]-  n <- levelView a-  m <- levelView b-  leqView n m+  a <- reduce a+  b <- reduce b+  catchConstraint (LevelCmp CmpLeq a b) $ leqView a b   where-    leqView n@(Max as) m@(Max bs) = do-      reportSDoc "tc.conv.nat" 10 $+    leqView a@(Max as) b@(Max bs) = do+      reportSDoc "tc.conv.nat" 30 $         text "compareLevelView" <+>-          sep [ text (show n) <+> text "=<"-              , text (show m) ]-      case (as, bs) of-        (_, [])  -> concat <$> sequence [ leqPlusView a (ClosedLevel 0) | a <- as ]-        (_, [b]) -> concat <$> sequence [ leqPlusView a b | a <- as ]-        _        -> do-          -- Each a needs to be less than at least one of the b's-          sequence [ choice [ leqPlusView a b | b <- bs ] | a <- as ]-          return []-    leqPlusView n m = do-      reportSDoc "tc.conv.nat" 10 $-        text "comparePlusView" <+>-          sep [ text (show n) <+> text "=<"-              , text (show m) ]-      case (n, m) of-        -- Both closed-        (ClosedLevel n, ClosedLevel m)-          | n <= m -> ok+          sep [ text (show a) <+> text "=<"+              , text (show b) ]+      wrap $ case (as, bs) of -        -- Both neutral-        (Plus n (NeutralLevel a), Plus m (NeutralLevel b))-          | n <= m -> do-            lvl <- primLevel-            equalTerm (El (mkType 0) lvl) a b+        -- same term+        _ | as == bs -> ok -        -- closed ≤ any-        (ClosedLevel n, Plus m _)-          | n <= m -> ok+        -- 0 ≤ any+        ([], _) -> ok -        -- Any blocked or meta-        (Plus _ BlockedLevel{}, _) -> postpone-        (_, Plus _ BlockedLevel{}) -> postpone-        (Plus _ MetaLevel{}, _)    -> postpone-        (_, Plus _ MetaLevel{})    -> postpone+        -- as ≤ 0+        (as, [])  -> sequence_ [ equalLevel (Max [a]) (Max []) | a <- as ] -        _ -> notok-    ok       = return []-    notok    = typeError $ NotLeqSort (Type a) (Type b)-    postpone = patternViolation+        -- as ≤ [b]+        (as@(_:_:_), [b]) -> sequence_ [ leqView (Max [a]) (Max [b]) | a <- as ] -    choice []     = patternViolation-    choice (m:ms) = noConstraints m `catchError` \_ -> choice ms+        -- reduce constants+        (as, bs) | minN > 0 -> leqView (Max $ map (subtr minN) as) (Max $ map (subtr minN) bs)+          where+            ns = map constant as+            ms = map constant bs+            minN = minimum (ns ++ ms)++        -- remove subsumed+        (as, bs)+          | not $ null dups -> leqView (Max $ as \\ dups) (Max bs)+          where+            dups = [ a | a@(Plus m l) <- as, Just n <- [findN l], m <= n ]+            findN a = case [ n | Plus n b <- bs, b == a ] of+                        [n] -> Just n+                        _   -> Nothing++        -- closed ≤ bs+        ([ClosedLevel n], bs)+          | n <= maximum (map constant bs) -> ok++        -- as ≤ neutral+        (as, bs)+          | neutralB && maxA > maxB -> notok+          | neutralB && any (\a -> neutral a && not (isInB a)) as -> notok+          | neutralB && neutralA -> maybeok $ all (\a -> constant a <= findN a) as+          where+            maxA = maximum $ map constant as+            maxB = maximum $ map constant bs+            neutralA = all neutral as+            neutralB = all neutral bs+            isInB a = elem (unneutral a) $ map unneutral bs+            findN a = case [ n | b@(Plus n _) <- bs, unneutral b == unneutral a ] of+                        [n] -> n+                        _   -> __IMPOSSIBLE__++        -- [a] ≤ [neutral]+        ([a@(Plus n _)], [b@(Plus m NeutralLevel{})])+          | m == n -> equalLevel (Max [a]) (Max [b])++        -- anything else+        _ -> postpone+      where+        ok       = return ()+        notok    = typeError $ NotLeqSort (Type a) (Type b)+        postpone = patternViolation++        wrap m = catchError m $ \e ->+          case errError e of+            TypeError{} -> notok+            _           -> throwError e++        maybeok True = ok+        maybeok False = notok++        neutral (Plus _ NeutralLevel{}) = True+        neutral _                       = False++        meta (Plus _ MetaLevel{}) = True+        meta _                    = False++        unneutral (Plus _ (NeutralLevel v)) = v+        unneutral _ = __IMPOSSIBLE__++        constant (ClosedLevel n) = n+        constant (Plus n _)      = n++        subtr m (ClosedLevel n) = ClosedLevel (n - m)+        subtr m (Plus n l)      = Plus (n - m) l++--     choice []     = patternViolation+--     choice (m:ms) = noConstraints m `catchError` \_ -> choice ms --       case errError e of --         PatternErr{} -> choice ms --         _            -> throwError e -equalLevel :: MonadTCM tcm => Term -> Term -> tcm Constraints+equalLevel :: Level -> Level -> TCM () equalLevel a b = do-  lvl    <- primLevel-  Max as <- levelView a-  Max bs <- levelView b-  a <- unLevelView (Max as)-  b <- unLevelView (Max bs)-  liftTCM $ catchConstraint (ValueCmp CmpEq (El (mkType 0) lvl) a b)-          $ check a b as bs+  a <- reduce a+  b <- reduce b+  reportSLn "tc.conv.level" 50 $ "equalLevel (" ++ show a ++ ") (" ++ show b ++ ")"+  liftTCM $ catchConstraint (LevelCmp CmpEq a b) $+    check a b   where-    check a b as bs = do-      reportSDoc "tc.conv.nat" 20 $+    check a@(Max as) b@(Max bs) = do+      reportSDoc "tc.conv.level" 40 $         sep [ text "equalLevel"-            , nest 2 $ sep [ prettyTCM a <+> text "=="-                           , prettyTCM b-                           ]-            , nest 2 $ sep [ text (show (Max as)) <+> text "=="-                           , text (show (Max bs))-                           ]+            , vcat [ nest 2 $ sep [ prettyTCM a <+> text "=="+                                  , prettyTCM b+                                  ]+                   , nest 2 $ sep [ text (show (Max as)) <+> text "=="+                                  , text (show (Max bs))+                                  ]+                   ]             ]       let a === b   = do             lvl <- getLvl             equalAtom lvl a b-          as =!= bs = do a <- unLevelView (Max as)-                         b <- unLevelView (Max bs)-                         a === b+          as =!= bs = levelTm (Max as) === levelTm (Max bs)+      as <- return $ closed0 as+      bs <- return $ closed0 bs       case (as, bs) of         _ | List.sort as == List.sort bs -> ok           | any isBlocked (as ++ bs) -> do               lvl <- getLvl-              liftTCM $ useInjectivity CmpEq lvl a b--        -- 0 == any-        ([], _) -> wrap $ concat <$> sequence [ as =!= [b] | b <- bs ]-        (_, []) -> wrap $ concat <$> sequence [ [a] =!= bs | a <- as ]+              liftTCM $ useInjectivity CmpEq lvl (Level a) (Level b)          -- closed == closed         ([ClosedLevel n], [ClosedLevel m])@@ -552,6 +657,14 @@         ([ClosedLevel{}], _) | any isNeutral bs -> notok         (_, [ClosedLevel{}]) | any isNeutral as -> notok +        -- 0 == any+        ([ClosedLevel 0], bs@(_:_:_)) -> sequence_ [ equalLevel (Max []) (Max [b]) | b <- bs ]+        (as@(_:_:_), [ClosedLevel 0]) -> sequence_ [ equalLevel (Max [a]) (Max []) | a <- as ]++        -- Same meta+        ([Plus n (MetaLevel x _)], [Plus m (MetaLevel y _)])+          | n == m && x == y -> ok+         -- meta == any         ([Plus n (MetaLevel x as)], _)           | any (isThisMeta x) bs -> postpone@@ -573,16 +686,21 @@         _ -> postpone        where-        ok       = return []+        ok       = return ()         notok    = typeError $ UnequalSorts (Type a) (Type b)-        postpone = patternViolation+        postpone = do+          reportSLn "tc.conv.level" 30 $ "postponing: " ++ show a ++ " == " ++ show b+          patternViolation +        closed0 [] = [ClosedLevel 0]+        closed0 as = as+         getLvl = El (mkType 0) <$> primLevel          meta n x as bs = do+          reportSLn "tc.meta.level" 50 $ "meta " ++ show as ++ " " ++ show bs           bs' <- mapM (subtr n) bs-          lvl <- getLvl-          assignV lvl x as =<< unLevelView (Max bs')+          assignV x as $ levelTm (Max bs')          -- Make sure to give a sensible error message         wrap m = m `catchError` \err ->@@ -598,6 +716,7 @@         subtr _ (Plus _ BlockedLevel{}) = postpone         subtr _ (Plus _ MetaLevel{})    = postpone         subtr _ (Plus _ NeutralLevel{}) = postpone+        subtr _ (Plus _ UnreducedLevel{}) = __IMPOSSIBLE__          isNeutral (Plus _ NeutralLevel{}) = True         isNeutral _                       = False@@ -618,81 +737,46 @@   -- | Check that the first sort equal to the second.-equalSort :: MonadTCM tcm => Sort -> Sort -> tcm Constraints+equalSort :: Sort -> Sort -> TCM () equalSort s1 s2 =-  ifM typeInType (return []) $+  ifM typeInType (return ()) $     catchConstraint (SortCmp CmpEq s1 s2) $ do         (s1,s2) <- reduce (s1,s2)-        reportSDoc "tc.conv.sort" 10 $+        reportSDoc "tc.conv.sort" 30 $           sep [ text "equalSort"-              , nest 2 $ fsep [ prettyTCM s1 <+> text "=="-                              , prettyTCM s2 ]+              , vcat [ nest 2 $ fsep [ prettyTCM s1 <+> text "=="+                                     , prettyTCM s2 ]+                     , nest 2 $ fsep [ text (show s1) <+> text "=="+                                     , text (show s2) ]+                     ]               ] 	case (s1,s2) of -            -- New universe polymorphism---             (Type a, Type b) -> compareLevel CmpEq a b--            (Type (Lit n), Type (Lit m))-              | n == m           -> return []-              | otherwise        -> notEq s1 s2             (Type a  , Type b  ) -> equalLevel a b -	    (MetaS x us , MetaS y vs) -> do-              s1 <- normalise s1-              s2 <- normalise s2-              if s1 == s2 then return []-			  else do-		[p1, p2] <- mapM getMetaPriority [x, y]-		if p1 >= p2 then assignS x us s2-			    else assignS y vs s1-	    (MetaS x vs, _       ) -> assignS x vs s2-	    (_	     , MetaS{} ) -> equalSort s2 s1--	    (Prop    , Prop    ) -> return []+	    (Prop    , Prop    ) -> return () 	    (Type _  , Prop    ) -> notEq s1 s2 	    (Prop    , Type _  ) -> notEq s1 s2 -	    (Suc s   , Prop    ) -> notEq s1 s2-	    (Suc s   , Type (Lit (LitLevel _ 0))) -> notEq s1 s2-	    (Suc s   , Type (Lit (LitLevel _ 1))) -> buildConstraint (SortCmp CmpEq s1 s2)-	    (Suc s   , Type (Lit (LitLevel _ n))) -> equalSort s (mkType $ n - 1)-	    (Prop    , Suc s   ) -> notEq s1 s2-	    (Type (Lit (LitLevel _ 0))  , Suc s   ) -> notEq s1 s2-	    (Type (Lit (LitLevel _ 1))  , Suc s   ) -> buildConstraint (SortCmp CmpEq s1 s2)-	    (Type (Lit (LitLevel _ n))  , Suc s   ) -> equalSort (mkType $ n - 1) s-            (Suc s1  , Suc s2  ) -> equalSort s1 s2 -- TODO: not what we want for Prop(?)-	    (_	     , Suc _   ) -> buildConstraint (SortCmp CmpEq s1 s2)-	    (Suc _   , _       ) -> buildConstraint (SortCmp CmpEq s1 s2)--            (Inf     , Inf     )             -> return []+            (Inf     , Inf     )             -> return ()+            (Inf     , Type (Max as@(_:_)))  -> mapM_ (isInf $ notEq s1 s2) as+            (Type (Max as@(_:_)), Inf)       -> mapM_ (isInf $ notEq s1 s2) as             (Inf     , _       )             -> notEq s1 s2             (_       , Inf     )             -> notEq s1 s2-            (s0@(Type (Lit (LitLevel _ 0))), Lub s1 s2) -> do-              cs1 <- equalSort s0 s1-              cs2 <- equalSort s0 s2-              return $ cs1 ++ cs2-            (Lub s1 s2, s0@(Type (Lit (LitLevel _ 0)))) -> do-              cs1 <- equalSort s1 s0-              cs2 <- equalSort s2 s0-              return $ cs1 ++ cs2-            (Lub{}   , Lub{}   ) -> do-              (s1, s2) <- normalise (s1, s2)-              if s1 == s2-                then return []-                else buildConstraint (SortCmp CmpEq s1 s2)-	    (Lub _ _ , _       ) -> buildConstraint (SortCmp CmpEq s1 s2)-	    (_	     , Lub _ _ ) -> buildConstraint (SortCmp CmpEq s1 s2) -            (DLub s1 s2, s0@(Type (Lit (LitLevel _ 0)))) -> do-              cs1 <- equalSort s1 s0-              cs2 <- underAbstraction_ s2 $ \s2 -> equalSort s2 s0-              return $ cs1 ++ cs2-            (s0@(Type (Lit (LitLevel _ 0))), DLub s1 s2) -> do-              cs1 <- equalSort s0 s1-              cs2 <- underAbstraction_ s2 $ \s2 -> equalSort s0 s2-              return $ cs1 ++ cs2-            (DLub{}  , _       )             -> buildConstraint (SortCmp CmpEq s1 s2)-            (_       , DLub{}  )             -> buildConstraint (SortCmp CmpEq s1 s2)+            (DLub s1 s2, s0@(Type (Max []))) -> do+              equalSort s1 s0+              underAbstraction_ s2 $ \s2 -> equalSort s2 s0+            (s0@(Type (Max [])), DLub s1 s2) -> do+              equalSort s0 s1+              underAbstraction_ s2 $ \s2 -> equalSort s0 s2+            (DLub{}  , _       )             -> addConstraint (SortCmp CmpEq s1 s2)+            (_       , DLub{}  )             -> addConstraint (SortCmp CmpEq s1 s2)     where 	notEq s1 s2 = typeError $ UnequalSorts s1 s2++        isInf notok ClosedLevel{} = notok+        isInf notok (Plus _ l) = case l of+          MetaLevel x vs          -> assignV x vs (Sort Inf)+          NeutralLevel (Sort Inf) -> return ()+          _                       -> notok

src/full/Agda/TypeChecking/Conversion.hs-boot view

@@ -4,15 +4,14 @@ import Agda.Syntax.Internal import Agda.TypeChecking.Monad -compareTerm :: MonadTCM tcm => Comparison -> Type -> Term -> Term -> tcm Constraints-compareAtom :: MonadTCM tcm => Comparison -> Type -> Term -> Term -> tcm Constraints-compareArgs :: MonadTCM tcm => [Polarity] -> Type -> Args -> Args -> tcm Constraints-compareType :: MonadTCM tcm => Comparison -> Type -> Type -> tcm Constraints-compareTel  :: MonadTCM tcm => Comparison -> Telescope -> Telescope -> tcm Constraints-compareSort :: MonadTCM tcm => Comparison -> Sort -> Sort -> tcm Constraints-equalTerm :: MonadTCM tcm => Type -> Term -> Term -> tcm Constraints-equalArgs :: MonadTCM tcm => Type -> Args -> Args -> tcm Constraints-equalType :: MonadTCM tcm => Type -> Type -> tcm Constraints-equalSort :: MonadTCM tcm => Sort -> Sort -> tcm Constraints--+compareTerm  :: Comparison -> Type -> Term -> Term -> TCM ()+compareAtom  :: Comparison -> Type -> Term -> Term -> TCM ()+compareArgs  :: [Polarity] -> Type -> Term -> Args -> Args -> TCM ()+compareElims :: [Polarity] -> Type -> Term -> [Elim] -> [Elim] -> TCM ()+compareType  :: Comparison -> Type -> Type -> TCM ()+compareTel   :: Type -> Type -> Comparison -> Telescope -> Telescope -> TCM ()+compareSort  :: Comparison -> Sort -> Sort -> TCM ()+equalTerm    :: Type -> Term -> Term -> TCM ()+equalType    :: Type -> Type -> TCM ()+equalSort    :: Sort -> Sort -> TCM ()+leqType      :: Type -> Type -> TCM ()

src/full/Agda/TypeChecking/Coverage.hs view

@@ -33,6 +33,7 @@ import Agda.TypeChecking.Reduce import Agda.TypeChecking.Primitive (constructorForm) import Agda.TypeChecking.Telescope+import Agda.TypeChecking.Irrelevance  import Agda.Interaction.Options @@ -74,12 +75,11 @@       pwords "Cannot pattern match on record" ++ [prettyTCM t] ++       pwords "because it has no constructor"     CantSplit c tel cIxs gIxs flex -> addCtxTel tel $ vcat-      [ fsep $ pwords "Cannot pattern match on constructor" ++ [prettyTCM c <> text ","] ++-               pwords "since the inferred indices"+      [ fsep $ pwords "Cannot decide whether there should be a case for the constructor" ++ [prettyTCM c <> text ","] +++               pwords "since the unification gets stuck on unifying the inferred indices"       , nest 2 $ prettyTCM cIxs-      , fsep $ pwords "cannot be unified with the expected indices"+      , fsep $ pwords "with the expected indices"       , nest 2 $ prettyTCM gIxs-      , fsep $ pwords "for some" ++ punctuate comma (map prettyTCM flex)       ]     GenericSplitError s -> fsep $       pwords "Split failed:" ++ pwords s@@ -106,10 +106,10 @@   TelV gamma _ <- telView $ defType d   let defn = theDef d   case defn of-    Function{ funClauses = cs'@(_:_) } -> do-      let cs           = map translatedClause cs'-          n            = genericLength $ clausePats $ head cs-          gamma'       = telFromList $ genericTake n $ telToList gamma+    Function{ funProjection = proj, funClauses = cs@(_:_) } -> do+      let n            = genericLength $ clausePats $ head cs+          np           = maybe 0 snd proj+          gamma'       = telFromList $ genericTake n $ genericDrop np $ telToList gamma           xs           = map (fmap $ const $ VarP "_") $ telToList gamma'       reportSDoc "tc.cover.top" 10 $ vcat         [ text "Coverage checking"@@ -122,18 +122,17 @@           _   ->             setCurrentRange (getRange cs) $               typeError $ CoverageFailure f pss-      whenM (optUnreachableCheck <$> pragmaOptions) $-        case Set.toList $ Set.difference (Set.fromList [0..genericLength cs - 1]) used of-          []  -> return ()-          is  -> do-            let unreached = map ((cs !!) . fromIntegral) is-            setCurrentRange (getRange unreached) $-              typeError $ UnreachableClauses f (map clausePats unreached)+      case Set.toList $ Set.difference (Set.fromList [0..genericLength cs - 1]) used of+        []  -> return ()+        is  -> do+          let unreached = map ((cs !!) . fromIntegral) is+          setCurrentRange (getRange unreached) $+            typeError $ UnreachableClauses f (map clausePats unreached)     _             -> __IMPOSSIBLE__  -- | Check that the list of clauses covers the given split clause. --   Returns the missing cases.-cover :: MonadTCM tcm => [Clause] -> SplitClause -> tcm (Set Nat, [[Arg Pattern]])+cover :: [Clause] -> SplitClause -> TCM (Set Nat, [[Arg Pattern]]) cover cs (SClause tel perm ps _) = do   reportSDoc "tc.cover.cover" 10 $ vcat     [ text "checking coverage of pattern:"@@ -148,18 +147,17 @@       let is = [ j | (j, c) <- zip [0..] (genericTake i cs), matchLits c ps perm ]       reportSLn "tc.cover.cover"  10 $ "literal matches: " ++ show is       return (Set.fromList (i : is), [])-    No             -> return (Set.empty, [ps])-    Block Nothing  -> fail $ "blocked by dot pattern"-    Block (Just x) -> do+    No      -> return (Set.empty, [ps])+    Block x -> do       r <- split Inductive tel perm ps x       case r of         Left err  -> case err of-          CantSplit c _ _ _ _   -> typeError $ CoverageCantSplitOn c-          NotADatatype a        -> typeError $ CoverageCantSplitType a-          IrrelevantDatatype a  -> typeError $ CoverageCantSplitType a-          CoinductiveDatatype a -> typeError $ CoverageCantSplitType a-          NoRecordConstructor a -> typeError $ CoverageCantSplitType a-          GenericSplitError s   -> fail $ "failed to split: " ++ s+          CantSplit c tel us vs _ -> typeError $ CoverageCantSplitOn c tel us vs+          NotADatatype a          -> typeError $ CoverageCantSplitType a+          IrrelevantDatatype a    -> typeError $ CoverageCantSplitIrrelevantType a+          CoinductiveDatatype a   -> typeError $ CoverageCantSplitType a+          NoRecordConstructor a   -> typeError $ CoverageCantSplitType a+          GenericSplitError s     -> fail $ "failed to split: " ++ s         Right scs -> (Set.unions -*- concat) . unzip <$> mapM (cover cs) scs  -- | Check that a type is a non-irrelevant datatype or a record with@@ -170,15 +168,17 @@               tcm (QName, [Arg Term], [Arg Term], [QName]) isDatatype ind at = do   let t = unArg at-  t' <- normalise t+  t' <- liftTCM $ reduce t   case unEl t' of     Def d args -> do-      def <- theDef <$> getConstInfo d+      def <- liftTCM $ theDef <$> getConstInfo d+      splitOnIrrelevantDataAllowed <- liftTCM $ optExperimentalIrrelevance <$> pragmaOptions       case def of         Datatype{dataPars = np, dataCons = cs, dataInduction = i}           | i == CoInductive && ind /= CoInductive ->               throwException $ CoinductiveDatatype t-          | argRelevance at == Irrelevant ->+          -- Andreas, 2011-10-03 allow some splitting on data (if only one constr. matches)+          | argRelevance at == Irrelevant && not splitOnIrrelevantDataAllowed ->               throwException $ IrrelevantDatatype t           | otherwise -> do               let (ps, is) = genericSplitAt np args@@ -194,16 +194,16 @@ computeNeighbourhood delta1 delta2 perm d pars ixs hix hps con = do    -- Get the type of the datatype-  dtype <- normalise =<< (`piApply` pars) . defType <$> getConstInfo d+  dtype <- liftTCM $ (`piApply` pars) . defType <$> getConstInfo d    -- Get the real constructor name-  Con con [] <- constructorForm =<< normalise (Con con [])+  Con con [] <- liftTCM $ constructorForm =<< normalise (Con con [])    -- Get the type of the constructor-  ctype <- defType <$> getConstInfo con+  ctype <- liftTCM $ defType <$> getConstInfo con    -- Lookup the type of the constructor at the given parameters-  TelV gamma (El _ (Def _ cixs)) <- telView (ctype `piApply` pars)+  TelV gamma (El _ (Def _ cixs)) <- liftTCM $ telView (ctype `piApply` pars)    debugInit con ctype pars ixs cixs delta1 delta2 gamma hps hix @@ -259,7 +259,7 @@       -- Apply the unifying substitution to Θ       -- We get ρ' : Θ' -> Θ       --        π  : Θ' -> Θ-      (theta', iperm, rho', _) <- instantiateTel sub' theta+      (theta', iperm, rho', _) <- liftTCM $ instantiateTel sub' theta       debugTel "theta'" theta'       debugShow "iperm" iperm @@ -282,7 +282,7 @@    where     debugInit con ctype pars ixs cixs delta1 delta2 gamma hps hix =-      reportSDoc "tc.cover.split.con" 20 $ vcat+      liftTCM $ reportSDoc "tc.cover.split.con" 20 $ vcat         [ text "computeNeighbourhood"         , nest 2 $ vcat           [ text "con    =" <+> prettyTCM con@@ -299,34 +299,34 @@         ]      debugNoUnify =-      reportSLn "tc.cover.split.con" 20 "  Constructor impossible!"+      liftTCM $ reportSLn "tc.cover.split.con" 20 "  Constructor impossible!"      debugCantSplit =-      reportSLn "tc.cover.split.con" 20 "  Bad split!"+      liftTCM $ reportSLn "tc.cover.split.con" 20 "  Bad split!"      debugSubst s sub =-      reportSDoc "tc.cover.split.con" 20 $ nest 2 $ vcat+      liftTCM $ reportSDoc "tc.cover.split.con" 20 $ nest 2 $ vcat         [ text (s ++ " =") <+> brackets (fsep $ punctuate comma $ map (maybe (text "_") prettyTCM) sub)         ]      debugTel s tel =-      reportSDoc "tc.cover.split.con" 20 $ nest 2 $ vcat+      liftTCM $ reportSDoc "tc.cover.split.con" 20 $ nest 2 $ vcat         [ text (s ++ " =") <+> prettyTCM tel         ]      debugShow s x =-      reportSDoc "tc.cover.split.con" 20 $ nest 2 $ vcat+      liftTCM $ reportSDoc "tc.cover.split.con" 20 $ nest 2 $ vcat         [ text (s ++ " =") <+> text (show x)         ]      debugPlugged ps ps' =-      reportSDoc "tc.cover.split.con" 20 $ nest 2 $ vcat+      liftTCM $ reportSDoc "tc.cover.split.con" 20 $ nest 2 $ vcat         [ text "ps     =" <+> text (show ps)         , text "ps'    =" <+> text (show ps')         ]      debugFinal tel perm ps =-      reportSDoc "tc.cover.split.con" 20 $ nest 2 $ vcat+      liftTCM $ reportSDoc "tc.cover.split.con" 20 $ nest 2 $ vcat         [ text "rtel   =" <+> prettyTCM tel         , text "rperm  =" <+> text (show perm)         , text "rps    =" <+> text (show ps)@@ -341,12 +341,11 @@ splitClauseWithAbs c x =   split' Inductive (clauseTel c) (clausePerm c) (clausePats c) x -split :: MonadTCM tcm-      => Induction+split :: Induction          -- ^ Coinductive constructors are allowed if this argument is          -- 'CoInductive'.       -> Telescope -> Permutation -> [Arg Pattern] -> Nat-      -> tcm (Either SplitError Covering)+      -> TCM (Either SplitError Covering) split ind tel perm ps x = do   r <- split' ind tel perm ps x   return $ case r of@@ -354,12 +353,11 @@     Right (Left _)  -> Right []     Right (Right c) -> Right c -split' :: MonadTCM tcm-       => Induction+split' :: Induction           -- ^ Coinductive constructors are allowed if this argument is           -- 'CoInductive'.        -> Telescope -> Permutation -> [Arg Pattern] -> Nat-       -> tcm (Either SplitError (Either SplitClause Covering))+       -> TCM (Either SplitError (Either SplitClause Covering)) split' ind tel perm ps x = liftTCM $ runExceptionT $ do    debugInit tel perm x ps@@ -370,7 +368,7 @@     return (telFromList tel1, telFromList tel2)    -- Get the type of the variable-  t <- normalise $ typeOfVar tel x  -- Δ₁ ⊢ t+  let t = typeOfVar tel x  -- Δ₁ ⊢ t    -- Compute the one hole context of the patterns at the variable   (hps, hix) <- do@@ -380,16 +378,16 @@      -- There is always a variable at the given hole.     let (hix, (VarP s, hps)) = holes !! fromIntegral x-    debugHoleAndType s hps t+    debugHoleAndType delta1 delta2 s hps t      return (hps, hix)    -- Check that t is a datatype or a record   -- Andreas, 2010-09-21, isDatatype now directly throws an exception if it fails-  (d, pars, ixs, cons) <- isDatatype ind t+  (d, pars, ixs, cons) <- inContextOfT $ isDatatype ind t -  whenM (optWithoutK <$> pragmaOptions) $-    Split.wellFormedIndices pars ixs+  liftTCM $ whenM (optWithoutK <$> pragmaOptions) $+    inContextOfT $ Split.wellFormedIndices pars ixs    -- Compute the neighbourhoods for the constructors   ns <- concat <$> mapM (computeNeighbourhood delta1 delta2 perm d pars ixs hix hps) cons@@ -405,25 +403,36 @@                , scSubst = [] -- not used anyway                } +    -- Andreas, 2011-10-03+    -- if more than one constructor matches, we cannot be irrelevant+    -- (this piece of code is unreachable if --experimental-irrelevance is off)+    (_ : _ : _) | unusableRelevance (argRelevance t) ->+      throwException $ IrrelevantDatatype (unArg t)+     _   -> return $ Right ns    where +    inContextOfT :: MonadTCM tcm => tcm a -> tcm a+    inContextOfT = escapeContext (fromIntegral x + 1)+     -- Debug printing     debugInit tel perm x ps =-      reportSDoc "tc.cover.top" 10 $ vcat+      liftTCM $ reportSDoc "tc.cover.top" 10 $ vcat         [ text "TypeChecking.Rules.LHS.Coverage.split': split"         , nest 2 $ vcat-          [ text "tel  =" <+> prettyTCM tel-          , text "perm =" <+> text (show perm)-          , text "x    =" <+> text (show x)-          , text "ps   =" <+> text (show ps)+          [ text "tel     =" <+> prettyTCM tel+          , text "perm    =" <+> text (show perm)+          , text "x       =" <+> text (show x)+          , text "ps      =" <+> text (show ps)           ]         ] -    debugHoleAndType s hps t =-      reportSDoc "tc.cover.top" 10 $ nest 2 $ vcat $-        [ text "p   =" <+> text s-        , text "hps =" <+> text (show hps)-        , text "t   =" <+> prettyTCM t+    debugHoleAndType delta1 delta2 s hps t =+      liftTCM $ reportSDoc "tc.cover.top" 10 $ nest 2 $ vcat $+        [ text "p      =" <+> text s+        , text "hps    =" <+> text (show hps)+        , text "delta1 =" <+> prettyTCM delta1+        , text "delta2 =" <+> prettyTCM delta2+        , text "t      =" <+> inContextOfT (prettyTCM t)         ]

src/full/Agda/TypeChecking/Coverage/Match.hs view

@@ -1,4 +1,4 @@-{-# LANGUAGE CPP #-}+{-# LANGUAGE CPP, DeriveFunctor #-}  module Agda.TypeChecking.Coverage.Match where @@ -27,7 +27,7 @@ buildMPatterns :: Permutation -> [Arg Pattern] -> [Arg MPat] buildMPatterns perm ps = evalState (mapM (traverse build) ps) xs   where-    xs   = permute (invertP perm) $ reverse [0 .. fromIntegral (size perm) - 1]+    xs   = permute (invertP perm) $ reverse [0 .. size perm - 1]     tick = do x : xs <- get; put xs; return x      build (VarP _)        = VarMP <$> tick@@ -40,14 +40,9 @@     buildT _              = return WildMP  -- | If matching is inconclusive (@Block@) we want to know which---   variable is blocking the match. If a dot pattern is blocking a match---   we're screwed.-data Match a = Yes a | No | Block (Maybe Nat)--instance Functor Match where-  fmap f (Yes a)   = Yes (f a)-  fmap f No        = No-  fmap f (Block x) = Block x+--   variable is blocking the match.+data Match a = Yes a | No | Block Nat+  deriving (Functor)  instance Monoid a => Monoid (Match a) where   mempty                    = Yes mempty@@ -110,8 +105,8 @@ matchPat _    (DotP _) _ = Yes () matchPat mlit (LitP l) q = mlit l q matchPat mlit (ConP c _ ps) q = case q of-  VarMP x -> Block $ Just x-  WildMP  -> Block Nothing+  VarMP x -> Block x+  WildMP  -> Yes ()   ConMP c' qs     | c == c'   -> matchPats mlit ps qs     | otherwise -> No

src/full/Agda/TypeChecking/Datatypes.hs view

@@ -17,7 +17,7 @@  -- | Get the name of the datatype constructed by a given constructor. --   Precondition: The argument must refer to a constructor-getConstructorData :: MonadTCM tcm => QName -> tcm QName+getConstructorData :: QName -> TCM QName getConstructorData c = do   def <- getConstInfo c   case theDef def of@@ -25,7 +25,7 @@     _                        -> __IMPOSSIBLE__  -- | Check if a name refers to a datatype or a record with a named constructor.-isDatatype :: MonadTCM tcm => QName -> tcm Bool+isDatatype :: QName -> TCM Bool isDatatype d = do   def <- getConstInfo d   case theDef def of@@ -33,6 +33,15 @@     Record{recNamedCon = namedC} -> return namedC     _                            -> return False +-- | Check if a name refers to a datatype or a record.+isDataOrRecordType :: QName -> TCM Bool+isDataOrRecordType d = do+  def <- getConstInfo d+  case theDef def of+    Datatype{} -> return True+    Record{}   -> return True+    _          -> return False+ data DatatypeInfo = DataInfo   { datatypeName   :: QName   , datatypeParTel :: Telescope@@ -43,7 +52,7 @@  -- | Get the name and parameters from a type if it's a datatype or record type --   with a named constructor.-getDatatypeInfo :: MonadTCM tcm => Type -> tcm (Maybe DatatypeInfo)+getDatatypeInfo :: Type -> TCM (Maybe DatatypeInfo) getDatatypeInfo t = do   t <- reduce t   case unEl t of

src/full/Agda/TypeChecking/Datatypes.hs-boot view

@@ -4,5 +4,4 @@ import Agda.TypeChecking.Monad.Base import Agda.Syntax.Internal -getConstructorData :: MonadTCM tcm => QName -> tcm QName-+getConstructorData :: QName -> TCM QName

src/full/Agda/TypeChecking/DisplayForm.hs view

@@ -20,7 +20,7 @@ displayForm :: QName -> Args -> TCM (Maybe DisplayTerm) displayForm c vs = do     odfs  <- defDisplay <$> getConstInfo c-    unless (null odfs) $ verboseS "tc.display.top" 30 $ do+    unless (null odfs) $ verboseS "tc.display.top" 100 $ do       n <- getContextId       let fvs = map (\(OpenThing n _) -> n) odfs       reportSLn "" 0 $ "displayForm: context = " ++ show n ++ ", dfs = " ++ show fvs@@ -31,10 +31,11 @@     let matches dfs vs = [ m | Just m <- map (flip matchDisplayForm vs) dfs, inScope scope m ]     -- Not safe when printing non-terminating terms.     -- (nfdfs, us) <- normalise (dfs, vs)-    unless (null odfs) $ reportSLn "tc.display.top" 20 $ unlines+    unless (null odfs) $ reportSLn "tc.display.top" 100 $ unlines       [ "displayForms: " ++ show dfs       , "arguments   : " ++ show vs       , "matches     : " ++ show (matches dfs vs)+      , "result      : " ++ show (foldr (const . Just) Nothing $ matches dfs vs)       ]     return $ foldr (const . Just) Nothing $ matches dfs vs -- ++ matches nfdfs us   `catchError` \_ -> return Nothing

+ src/full/Agda/TypeChecking/Eliminators.hs view

@@ -0,0 +1,71 @@+{-# LANGUAGE CPP #-}++module Agda.TypeChecking.Eliminators where++import Control.Applicative+import Control.Monad++import Agda.Syntax.Common+import Agda.Syntax.Internal+import Agda.TypeChecking.Monad+import Agda.TypeChecking.Substitute+import Agda.Utils.Impossible+import Agda.TypeChecking.Reduce++#include "../undefined.h"++data ElimView = VarElim Nat [Elim]+              | DefElim QName [Elim]+              | ConElim QName [Elim]+              | MetaElim MetaId [Elim]+              | NoElim Term++elimView :: Term -> TCM ElimView+elimView v = do+  -- We can't assume that v has been reduced here in recursive calls,+  -- since reducing a stuck application doesn't necessarily reduces all+  -- the arguments.+  v <- reduce v+  case v of+    Def f vs -> do+      proj <- isProjection f+      case proj of+        Nothing -> DefElim f `app` vs+        Just{}  -> do+          case vs of+            rv : vs' -> elim (Proj f : map Apply vs') <$> elimView (unArg rv)+            [] -> __IMPOSSIBLE__+              -- elimView should only be called from the conversion checker+              -- with properly saturated applications+    Var x vs   -> VarElim x `app` vs+    Con c vs   -> ConElim c `app` vs+    MetaV m vs -> MetaElim m `app` vs+    Lam{}      -> noElim+    Lit{}      -> noElim+    Level{}    -> noElim+    Sort{}     -> noElim+    Pi{}       -> noElim+    DontCare{} -> noElim+    where+      noElim = return $ NoElim v+      app f vs = return $ f $ map Apply vs+      elim :: [Elim] -> ElimView -> ElimView+      elim _    NoElim{}        = __IMPOSSIBLE__+      elim es2 (VarElim  x es1) = VarElim  x (es1 ++ es2)+      elim es2 (DefElim  x es1) = DefElim  x (es1 ++ es2)+      elim es2 (ConElim  x es1) = ConElim  x (es1 ++ es2)+      elim es2 (MetaElim x es1) = MetaElim x (es1 ++ es2)++-- | Only used when producing error messages.+unElimView :: ElimView -> Term+unElimView v = case v of+  VarElim x es  -> unElim (Var x []) es+  DefElim x es  -> unElim (Def x []) es+  ConElim x es  -> unElim (Con x []) es+  MetaElim x es -> unElim (MetaV x []) es+  NoElim v      -> v++unElim :: Term -> [Elim] -> Term+unElim v [] = v+unElim v (Apply u : es) = unElim (v `apply` [u]) es+unElim v (Proj f : es)  = unElim (Def f [Arg NotHidden Relevant v]) es

src/full/Agda/TypeChecking/Empty.hs view

@@ -10,29 +10,36 @@ import Agda.TypeChecking.Coverage import Agda.TypeChecking.Constraints import Agda.TypeChecking.Reduce+import Agda.TypeChecking.Substitute  import Agda.Utils.Permutation import Agda.Utils.Size  -- | Make sure that a type is empty.-isEmptyType :: MonadTCM tcm => Type -> tcm ()-isEmptyType t = noConstraints $ isEmptyTypeC t+isReallyEmptyType :: Type -> TCM ()+isReallyEmptyType t = noConstraints $ isEmptyType t -isEmptyTypeC :: MonadTCM tcm => Type -> tcm Constraints-isEmptyTypeC t = do+isEmptyType :: Type -> TCM ()+isEmptyType t = do   tb <- reduceB t   let t = ignoreBlocking tb   case unEl <$> tb of-    NotBlocked MetaV{} -> buildConstraint (IsEmpty t)-    Blocked{}          -> buildConstraint (IsEmpty t)+    -- if t is blocked or a meta, we cannot decide emptyness now. postpone+    NotBlocked MetaV{} -> addConstraint (IsEmpty t)+    Blocked{}          -> addConstraint (IsEmpty t)     _                  -> do+    -- from the current context xs:ts, create a pattern list+    -- xs _ : ts t and try to split on _ (the last variable)       tel0 <- getContextTelescope-      let tel = telFromList $ telToList tel0 ++ [defaultArg ("_", t)]-          ps  = [ Arg h r $ VarP x | Arg h r (x, _) <- telToList tel ]+      let gamma = telToList tel0 ++ [defaultArg ("_", t)]+          ps    = [ Arg h r $ VarP x | Arg h r (x, _) <- gamma ]+          tel   = telFromList gamma        r <- split Inductive tel (idP $ size tel) ps 0        case r of-        Left err  -> typeError $ ShouldBeEmpty t []-        Right []  -> return []+        Left err  -> case err of+          CantSplit c tel us vs _ -> traceCall (CheckIsEmpty t) $ typeError $ CoverageCantSplitOn c tel us vs+          _                       -> typeError $ ShouldBeEmpty t []+        Right []  -> return ()         Right cs  -> typeError $ ShouldBeEmpty t $ map (unArg . last . scPats) cs

src/full/Agda/TypeChecking/Empty.hs-boot view

@@ -1,9 +1,8 @@  module Agda.TypeChecking.Empty where -import Agda.TypeChecking.Monad (MonadTCM, Constraints)+import Agda.TypeChecking.Monad (TCM) import Agda.Syntax.Internal (Type) -isEmptyType :: MonadTCM tcm => Type -> tcm ()-isEmptyTypeC :: MonadTCM tcm => Type -> tcm Constraints-+isReallyEmptyType :: Type -> TCM ()+isEmptyType       :: Type -> TCM ()

src/full/Agda/TypeChecking/Errors.hs view

@@ -39,7 +39,7 @@ -- * Top level function --------------------------------------------------------------------------- -prettyError :: MonadTCM tcm => TCErr -> tcm String+prettyError :: TCErr -> TCM String prettyError err = liftTCM $ liftM show $     prettyTCM err     `catchError` \err' -> text "panic: error when printing error!" $$ prettyTCM err'@@ -53,17 +53,17 @@ -- * Helpers --------------------------------------------------------------------------- -sayWhere :: (MonadTCM tcm, HasRange a) => a -> tcm Doc -> tcm Doc+sayWhere :: HasRange a => a -> TCM Doc -> TCM Doc sayWhere x d = text (show $ getRange x) $$ d -sayWhen :: MonadTCM tcm => Range -> Maybe (Closure Call) -> tcm Doc -> tcm Doc+sayWhen :: Range -> Maybe (Closure Call) -> TCM Doc -> TCM Doc sayWhen r Nothing   m = sayWhere r m sayWhen r (Just cl) m = sayWhere r (m $$ prettyTCM cl) -panic :: MonadTCM tcm => String -> tcm Doc+panic :: String -> TCM Doc panic s = fwords $ "Panic: " ++ s -nameWithBinding :: MonadTCM tcm => QName -> tcm Doc+nameWithBinding :: QName -> TCM Doc nameWithBinding q =   sep [ prettyTCM q, text "bound at", text (show r) ]   where@@ -75,7 +75,7 @@     Exception r s   -> show r ++ " " ++ s     IOException r e -> show r ++ " " ++ show e     PatternErr _    -> "PatternErr"-    AbortAssign _   -> "AbortAssign"+    {- AbortAssign _   -> "AbortAssign" -- UNUSED -}  errorString :: TypeError -> String errorString err = case err of@@ -96,6 +96,7 @@     ConstructorPatternInWrongDatatype{}      -> "ConstructorPatternInWrongDatatype"     CoverageFailure{}                        -> "CoverageFailure"     CoverageCantSplitOn{}                    -> "CoverageCantSplitOn"+    CoverageCantSplitIrrelevantType{}        -> "CoverageCantSplitIrrelevantType"     CoverageCantSplitType{}                  -> "CoverageCantSplitType"     CyclicModuleDependency{}                 -> "CyclicModuleDependency"     DataMustEndInSort{}                      -> "DataMustEndInSort"@@ -108,6 +109,7 @@     FieldOutsideRecord                       -> "FieldOutsideRecord"     FileNotFound{}                           -> "FileNotFound"     GenericError{}                           -> "GenericError"+    IFSNoCandidateInScope{}                  -> "IFSNoCandidateInScope"     IlltypedPattern{}                        -> "IlltypedPattern"     IncompletePatternMatching{}              -> "IncompletePatternMatching"     IndexFreeInParameter{}                   -> "IndexFreeInParameter"@@ -141,10 +143,14 @@     NotLeqSort{}                             -> "NotLeqSort"     NotStrictlyPositive{}                    -> "NotStrictlyPositive"     NothingAppliedToHiddenArg{}              -> "NothingAppliedToHiddenArg"+    NothingAppliedToInstanceArg{}            -> "NothingAppliedToInstanceArg"     OverlappingProjects {}                   -> "OverlappingProjects"     PatternShadowsConstructor {}             -> "PatternShadowsConstructor"     PropMustBeSingleton                      -> "PropMustBeSingleton"     RepeatedVariablesInPattern{}             -> "RepeatedVariablesInPattern"+    SafeFlagPostulate{}                      -> "SafeFlagPostulate"+    SafeFlagPragma{}                         -> "SafeFlagPragma"+    SafeFlagPrimTrustMe{}                    -> "SafeFlagPrimTrustMe"     ShadowedModule{}                         -> "ShadowedModule"     ShouldBeASort{}                          -> "ShouldBeASort"     ShouldBeApplicationOf{}                  -> "ShouldBeApplicationOf"@@ -167,6 +173,7 @@     UnequalTerms{}                           -> "UnequalTerms"     UnequalTypes{}                           -> "UnequalTypes"     UnequalTelescopes{}                      -> "UnequalTelescopes"+    HeterogeneousEquality{}                  -> "HeterogeneousEquality"     UnexpectedWithPatterns{}                 -> "UnexpectedWithPatterns"     UninstantiatedDotPattern{}               -> "UninstantiatedDotPattern"     UninstantiatedModule{}                   -> "UninstantiatedModule"@@ -177,6 +184,7 @@     WrongHidingInApplication{}               -> "WrongHidingInApplication"     WrongHidingInLHS{}                       -> "WrongHidingInLHS"     WrongHidingInLambda{}                    -> "WrongHidingInLambda"+    WrongIrrelevanceInLambda{}               -> "WrongIrrelevanceInLambda"     WrongNumberOfConstructorArguments{}      -> "WrongNumberOfConstructorArguments"  instance PrettyTCM TCErr where@@ -190,7 +198,7 @@ 	Exception r s   -> sayWhere r $ fwords s 	IOException r e -> sayWhere r $ fwords $ show e 	PatternErr _    -> sayWhere err $ panic "uncaught pattern violation"-	AbortAssign _   -> sayWhere err $ panic "uncaught aborted assignment"+	{- AbortAssign _   -> sayWhere err $ panic "uncaught aborted assignment" -- UNUSED -}  instance PrettyTCM TypeError where     prettyTCM err = do@@ -200,10 +208,18 @@ 	    NotSupported s -> fwords $ "Not supported: " ++ s 	    CompilationError s -> sep [fwords "Compilation error:", text s] 	    GenericError s   -> fwords s-	    TerminationCheckFailed because -> fsep $-	      pwords "Termination checking failed for the following functions:" ++-              [ fsep (punctuate comma (map (text . show . qnameName)-                                           (concatMap fst because))) <> text "." ]+	    TerminationCheckFailed because ->+              fwords "Termination checking failed for the following functions:"+              $$ (nest 2 $+                    fsep (punctuate comma (map (text . show . qnameName)+                                               (concatMap termErrFunctions because))))+              $$ fwords "Problematic calls:"+              $$ (nest 2 $ vcat $+                    map (\c -> let call = text (callInfoCall c) in+                               case show (callInfoRange c) of+                                 "" -> call+                                 r  -> call $$ nest 2 (text "(at" <+> text r <> text ")"))+                        (concatMap termErrCalls because)) 	    PropMustBeSingleton -> fwords 		"Datatypes in Prop must have at most one constructor when proof irrelevance is enabled" 	    DataMustEndInSort t -> fsep $@@ -226,6 +242,8 @@ 		fwords "Found an implicit argument where an explicit argument was expected" 	    WrongHidingInLambda t -> do 		fwords "Found an implicit lambda where an explicit lambda was expected"+	    WrongIrrelevanceInLambda t -> do+		fwords "Found an irrelevant lambda where a relevant lambda was expected" 	    WrongHidingInApplication t -> do 		fwords "Found an implicit application where an explicit application was expected"             NotInductive t -> fsep $@@ -245,7 +263,8 @@             ConstructorPatternInWrongDatatype c d -> fsep $               [prettyTCM c] ++ pwords "is not a constructor of the datatype" ++ [prettyTCM d]             IndicesNotConstructorApplications is ->-              fsep (pwords "The following indices are not constructors applied to variables:")+              fsep (pwords "The following indices are not constructors" +++                    pwords "(or literals) applied to variables:")               $$ nest 2 (vcat $ map prettyTCM is)             IndexVariablesNotDistinct is ->               fsep (pwords "The variables in the following indices are not distinct:")@@ -273,7 +292,7 @@               pwords "The arguments to " ++ [prettyTCM m] ++ pwords "does not fit the telescope" ++ 	      [prettyTCM tel]             ShouldBeEmpty t [] -> fsep $-		[prettyTCM t] ++ pwords "should be empty, but it isn't obvious that it is."+		[prettyTCM t] ++ pwords "should be empty, but that's not obvious to me" 	    ShouldBeEmpty t ps -> fsep ( 		[prettyTCM t] ++                 pwords "should be empty, but the following constructor patterns are valid:"@@ -286,12 +305,12 @@ 	    NotAProperTerm -> 		fwords "Found a malformed term"             SplitOnIrrelevant p t -> fsep $-                pwords "cannot pattern match" ++ [prettyA p] +++                pwords "Cannot pattern match" ++ [prettyA p] ++                 pwords "against irrelevant type" ++ [prettyTCM t]             DefinitionIsIrrelevant x -> fsep $-                text "identifier" : prettyTCM x : pwords "is declared irrelevant, so it cannot be used here"+                text "Identifier" : prettyTCM x : pwords "is declared irrelevant, so it cannot be used here"             VariableIsIrrelevant x -> fsep $-                text "variable" : prettyTCM x : pwords "is declared irrelevant, so it cannot be used here"+                text "Variable" : prettyTCM x : pwords "is declared irrelevant, so it cannot be used here"  	    UnequalTerms cmp s t a -> fsep $ 		[prettyTCM s, f cmp, prettyTCM t] ++ pwords "of type" ++ [prettyTCM a]                 where@@ -312,6 +331,10 @@                 where                   f CmpEq  = text "!="                   f CmpLeq = text "!=<"+	    HeterogeneousEquality u a v b -> fsep $+                pwords "Refuse to solve heterogeneous constraint" +++                [prettyTCM u] ++ pwords ":" ++ [prettyTCM a] ++ pwords "=?=" +++                [prettyTCM v] ++ pwords ":" ++ [prettyTCM b] 	    UnequalRelevance a b -> fsep $ 		[prettyTCM a] ++ pwords "!=" ++ [prettyTCM b] ++ -- Andreas 2010-09-21 to reveal Forced annotations, print also uglily@@ -477,6 +500,9 @@ 	    NothingAppliedToHiddenArg e	-> fsep $ 		[pretty e] ++ pwords "cannot appear by itself. It needs to be the argument to" ++ 		pwords "a function expecting an implicit argument."+	    NothingAppliedToInstanceArg e -> fsep $+		[pretty e] ++ pwords "cannot appear by itself. It needs to be the argument to" +++		pwords "a function expecting an instance argument." 	    NoParseForApplication es -> fsep $ 		pwords "Could not parse the application" ++ [pretty $ C.RawApp noRange es] 	    AmbiguousParseForApplication es es' -> fsep (@@ -511,9 +537,16 @@                       then return ps                       else return ps  -- TODO: remove implicit arguments which aren't constructors -            CoverageCantSplitOn c -> fsep $-              pwords "Cannot split on the constructor" ++ [prettyTCM c]+            CoverageCantSplitOn c tel cIxs gIxs -> inContext [] $ addCtxTel tel $ vcat+              [ fsep $ pwords "Cannot decide whether there should be a case for the constructor" ++ [prettyTCM c <> text ","] +++                       pwords "since the unification gets stuck on unifying the inferred indices"+              , nest 2 $ prettyTCM cIxs+              , fsep $ pwords "with the expected indices"+              , nest 2 $ prettyTCM gIxs ] +            CoverageCantSplitIrrelevantType a -> fsep $+              pwords "Cannot split on argument of irrelevant datatype" ++ [prettyTCM a]+             CoverageCantSplitType a -> fsep $               pwords "Cannot split on argument of non-datatype" ++ [prettyTCM a] @@ -543,13 +576,23 @@  		    com []    = empty 		    com (_:_) = comma-+            IFSNoCandidateInScope t -> fsep $+                pwords "No variable of type" ++ [prettyTCM t] ++ pwords "was found in scope."+            SafeFlagPostulate e -> fsep $+                pwords "Cannot postulate" ++ [pretty e] ++ pwords "with safe flag"+            SafeFlagPragma xs ->+                let plural | length xs == 1 = ""+                           | otherwise      = "s"+                in fsep $ [fwords ("Cannot set OPTION pragma" ++ plural)]+                          ++ map text xs ++ [fwords "with safe flag."]+            SafeFlagPrimTrustMe -> fsep (pwords "Cannot use primTrustMe with safe flag")           where             mpar n args               | n > 0 && not (null args) = parens               | otherwise                = id              showArg (Arg Hidden r x)    = braces $ showPat 0 x+            showArg (Arg Instance r x)  = dbraces $ showPat 0 x             showArg (Arg NotHidden r x) = showPat 1 x              showPat _ (I.VarP _)        = text "_"@@ -598,6 +641,9 @@ 	CheckPrimitive _ x e _ -> fsep $ 	    pwords "when checking that the type of the primitive function" ++ 	    [prettyTCM x] ++ pwords "is" ++ [prettyA e]+        CheckWithFunctionType e _ -> fsep $+            pwords "when checking that the type" +++            [prettyA e] ++ pwords "of the generated with function is well-formed"         CheckDotPattern e v _ -> fsep $             pwords "when checking that the given dot pattern" ++ [prettyA e] ++             pwords "matches the inferred value" ++ [prettyTCM v]@@ -607,14 +653,13 @@ 	    fsep $ pwords "when inferring the type of" ++ [prettyTCM x] 	InferDef _ x _ -> 	    fsep $ pwords "when inferring the type of" ++ [prettyTCM x]+        CheckIsEmpty t _ ->+            fsep $ pwords "when checking that" ++ [prettyTCM t] ++ pwords "has no constructors" 	ScopeCheckExpr e _ -> 	    fsep $ pwords "when scope checking" ++ [pretty e] 	ScopeCheckDeclaration d _ -> 	    fwords "when scope checking the declaration" $$ 	    nest 2 (pretty $ simpleDecl d)-	ScopeCheckDefinition d _ ->-	    fwords "when scope checking the definition" $$-	    nest 2 (vcat $ map pretty $ simpleDef d) 	ScopeCheckLHS x p _ -> 	    fsep $ pwords "when scope checking the left-hand side" ++ [pretty p] ++ 		   pwords "in the definition of" ++ [pretty x]@@ -622,41 +667,15 @@ 	    fsep $ pwords "when termination checking the definition of" ++ [prettyTCM f] 	SetRange r _ -> 	    fsep $ pwords "when doing something at" ++ [text $ show r]-        CheckSectionApplication _ m1 ptel m2 args _ -> fsep $+        CheckSectionApplication _ m1 modapp _ -> fsep $           pwords "when checking the module application" ++-          [prettyA $ A.Apply info m1 ptel m2 args Map.empty Map.empty]+          [prettyA $ A.Apply info m1 modapp Map.empty Map.empty]           where             info = A.ModuleInfo noRange noRange Nothing Nothing Nothing  	where 	    hPretty a = pretty =<< abstractToConcreteCtx (hiddenArgumentCtx (argHiding a)) a -	    simpleDef d = case d of-	      D.FunDef _ ds _ _ _ _ _	 -> ds-	      D.DataDef r fx p a d bs cs ->-		[ C.Data r Inductive d (map bind bs) (C.Underscore noRange Nothing)-		    $ map simpleDecl cs-		]-	      D.RecDef r fx p a d c bs cs ->-		[ C.Record r d (name <$> c) (map bind bs) (C.Underscore noRange Nothing)-		    $ map simpleDecl cs-		]-	      where-		bind :: C.LamBinding -> C.TypedBindings-		bind (C.DomainFull b) = b-		bind (C.DomainFree h x) = C.TypedBindings r $ Arg h Relevant [C.TBind r [x] (C.Underscore r Nothing)]-		  where r = getRange x--                name (D.Axiom _ _ _ _ _ n _) = n-                name _                     = __IMPOSSIBLE__+	    simpleDecl d = d'+              where [d'] = D.notSoNiceDeclarations [d] -	    simpleDecl d = case d of-		D.Axiom _ _ _ _ rel x e		       -> C.TypeSig rel x e-		D.NiceField _ _ _ _ x e	               -> C.Field x e-		D.PrimitiveFunction r _ _ _ x e	       -> C.Primitive r [C.TypeSig Relevant x e]-		D.NiceDef r ds _ _		       -> C.Mutual r ds-		D.NiceModule r _ _ x tel _	       -> C.Module r x tel []-		D.NiceModuleMacro r _ _ x tel e op dir -> C.ModuleMacro r x tel e op dir-		D.NiceOpen r x dir		       -> C.Open r x dir-		D.NiceImport r x as op dir	       -> C.Import r x as op dir-		D.NicePragma _ p		       -> C.Pragma p

src/full/Agda/TypeChecking/EtaContract.hs view

@@ -26,32 +26,40 @@   Def c xs   -> app (Def c) xs   Con c xs   -> app (Con c) xs   Lit _      -> noApp+  Level _    -> noApp   -- could be an application, but let's not eta contract levels   Lam _ _    -> noApp   Pi _ _     -> noApp-  Fun _ _    -> noApp   Sort _     -> noApp   MetaV _ _  -> noApp-  DontCare   -> noApp+  DontCare _ -> noApp   where     noApp = NoApp t     app f [] = noApp     app f xs = App (f $ init xs) (last xs) -etaContract :: (MonadTCM tcm, TermLike a) => a -> tcm a+etaContract :: TermLike a => a -> TCM a etaContract = traverseTermM etaOnce   where -etaOnce :: (MonadTCM tcm) => Term -> tcm Term+etaOnce :: Term -> TCM Term etaOnce v = ignoreAbstractMode $ eta v   where-    eta t@(Lam h b) = do+    eta t@(Lam h (Abs _ b)) = do  -- NoAbs can't be eta'd       imp <- shouldEtaContractImplicit-      case binAppView (absBody b) of-        App u (Arg h' r (Var 0 []))-          | allowed imp h' && not (freeIn 0 u) ->+      case binAppView b of+        App u (Arg h' r v)+          | isVar0 v && allowed imp h' && not (freeIn 0 u) ->             return $ subst __IMPOSSIBLE__ u         _ -> return t       where+        isVar0 (Var 0 [])               = True+        isVar0 (DontCare{})             = True  -- Andreas, 2011-10-01 eta-contract irrelevant functions also+        isVar0 (Level (Max [Plus 0 l])) = case l of+          NeutralLevel v   -> isVar0 v+          UnreducedLevel v -> isVar0 v+          BlockedLevel{}   -> False+          MetaLevel{}      -> False+        isVar0 _ = False         allowed imp h' = h == h' && (imp || h == NotHidden)     eta t@(Con c args) = do       r <- getConstructorData c

src/full/Agda/TypeChecking/Forcing.hs view

@@ -42,8 +42,9 @@     ifM (isInj d)         (forcedArgs vs)         (return [])-  Fun a b -> (++) <$> forcedVariables (unEl $ unArg a)-                  <*> forcedVariables (unEl b)+  Pi a (NoAbs _ b) ->+    (++) <$> forcedVariables (unEl $ unArg a)+         <*> forcedVariables (unEl b)   Pi a b -> (++) <$> forcedVariables (unEl $ unArg a)                  <*> (underBinder <$> forcedVariables (unEl $ absBody b))   -- Sorts?@@ -56,7 +57,7 @@       return $ case theDef def of         Datatype{} -> True         Record{}   -> True-        Axiom{}    -> True+        -- Axiom{}    -> True -- Postulates are not injective in general, right? /Olle 2011-05-05         _          -> False  force :: [Nat] -> Type -> Type@@ -65,7 +66,6 @@     m = maximum (-1:xs)     aux i t | i > m = t     aux i t = case t of-      El s (Fun a b) -> El s $ Fun (upd a) (aux (i + 1) b)       El s (Pi  a b) -> El s $ Pi  (upd a) (fmap (aux (i + 1)) b)       _ -> __IMPOSSIBLE__       where

src/full/Agda/TypeChecking/Free.hs view

@@ -6,12 +6,17 @@     , Free     , freeVars     , allVars-    , freeIn+    , relevantVars+    , rigidVars+    , freeIn, isBinderUsed     , freeInIgnoringSorts+    , relevantIn+    , Occurrence(..)+    , occurrence     ) where -import qualified Data.Set as Set-import Data.Set (Set)+import qualified Agda.Utils.VarSet as Set+import Agda.Utils.VarSet (VarSet)  import Agda.Syntax.Common import Agda.Syntax.Internal@@ -19,41 +24,98 @@ #include "../undefined.h" import Agda.Utils.Impossible -data FreeVars = FV { rigidVars	  :: Set Nat-		   , flexibleVars :: Set Nat-		   }+-- | The distinction between rigid and strongly rigid occurrences comes from:+--   Jason C. Reed, PhD thesis, 2009, page 96 (see also his LFMTP 2009 paper)+--+-- The main idea is that x = t(x) is unsolvable if x occurs strongly rigidly+-- in t.  It might have a solution if the occurrence is not strongly rigid, e.g.+--+--   x = \f -> suc (f (x (\ y -> k)))  has  x = \f -> suc (f (suc k))+--+-- [Jason C. Reed, PhD thesis, page 106] -allVars :: FreeVars -> Set Nat-allVars fv = Set.union (rigidVars fv) (flexibleVars fv)+-- | Free variables of a term, (disjointly) partitioned into strongly and+--   and weakly rigid variables, flexible variables and irrelevant variables.+data FreeVars = FV+  { stronglyRigidVars :: VarSet -- ^ variables at top and under constructors+  , weaklyRigidVars   :: VarSet -- ^ ord. rigid variables, e.g., in arguments of variables+  , flexibleVars      :: VarSet -- ^ variables occuring in arguments of metas. These are potentially free, depending how the meta variable is instantiated.+  , irrelevantVars    :: VarSet -- ^ variables under a @DontCare@, i.e., in irrelevant positions+  } +rigidVars :: FreeVars -> VarSet+rigidVars fv = Set.union (stronglyRigidVars fv) (weaklyRigidVars fv)++-- | @allVars fv@ includes irrelevant variables.+allVars :: FreeVars -> VarSet+allVars fv = Set.unions [rigidVars fv, flexibleVars fv, irrelevantVars fv]++-- | All but the irrelevant variables.+relevantVars :: FreeVars -> VarSet+relevantVars fv = Set.unions [rigidVars fv, flexibleVars fv]++data Occurrence+  = NoOccurrence+  | StronglyRigid+  | WeaklyRigid+  | Flexible+  deriving (Eq,Show)++-- | @occurrence x fv@ ignores irrelevant variables in @fv@+occurrence :: Nat -> FreeVars -> Occurrence+occurrence x fv+  | x `Set.member` stronglyRigidVars fv = StronglyRigid+  | x `Set.member` weaklyRigidVars   fv = WeaklyRigid+  | x `Set.member` flexibleVars      fv = Flexible+  | otherwise                           = NoOccurrence++-- | Mark variables as flexible.  Useful when traversing arguments of metas. flexible :: FreeVars -> FreeVars flexible fv =-    FV { rigidVars    = Set.empty-       , flexibleVars = allVars fv+    fv { stronglyRigidVars = Set.empty+       , weaklyRigidVars   = Set.empty+       , flexibleVars      = relevantVars fv        } +-- | Mark rigid variables as non-strongly.  Useful when traversion arguments of variables.+weakly :: FreeVars -> FreeVars+weakly fv = fv+  { stronglyRigidVars = Set.empty+  , weaklyRigidVars   = rigidVars fv+  }++-- | Mark all free variables as irrelevant.+irrelevantly :: FreeVars -> FreeVars+irrelevantly fv = empty { irrelevantVars = allVars fv }++-- | Pointwise union. union :: FreeVars -> FreeVars -> FreeVars-union (FV rv1 fv1) (FV rv2 fv2) = FV (Set.union rv1 rv2) (Set.union fv1 fv2)+union (FV sv1 rv1 fv1 iv1) (FV sv2 rv2 fv2 iv2) =+  FV (Set.union sv1 sv2) (Set.union rv1 rv2) (Set.union fv1 fv2) (Set.union iv1 iv2)  unions :: [FreeVars] -> FreeVars unions = foldr union empty  empty :: FreeVars-empty = FV Set.empty Set.empty--mapFV :: (Nat -> Nat) -> FreeVars -> FreeVars-mapFV f (FV rv fv) = FV (Set.map f rv) (Set.map f fv)+empty = FV Set.empty Set.empty Set.empty Set.empty +-- | @delete x fv@ deletes variable @x@ from variable set @fv@. delete :: Nat -> FreeVars -> FreeVars-delete x (FV rv fv) = FV (Set.delete x rv) (Set.delete x fv)+delete n (FV sv rv fv iv) = FV (Set.delete n sv) (Set.delete n rv) (Set.delete n fv) (Set.delete n iv) +-- | @subtractFV n fv@ subtracts $n$ from each free variable in @fv@.+subtractFV :: Nat -> FreeVars -> FreeVars+subtractFV n (FV sv rv fv iv) = FV (Set.subtract n sv) (Set.subtract n rv) (Set.subtract n fv) (Set.subtract n iv)++-- | A single (strongly) rigid variable. singleton :: Nat -> FreeVars-singleton x = FV { rigidVars	= Set.singleton x-		 , flexibleVars = Set.empty+singleton x = FV { stronglyRigidVars = Set.singleton x+		 , weaklyRigidVars   = Set.empty -- WAS: Set.singleton x+		 , flexibleVars      = Set.empty+                 , irrelevantVars    = Set.empty 		 } --- | Doesn't go inside solved metas, but collects the variables from a--- metavariable application @X ts@ as @flexibleVars@.+-- * Collecting free variables.  class Free a where   freeVars' :: FreeConf -> a -> FreeVars@@ -63,21 +125,26 @@     -- ^ Ignore free variables in sorts.   } +-- | Doesn't go inside solved metas, but collects the variables from a+-- metavariable application @X ts@ as @flexibleVars@. freeVars :: Free a => a -> FreeVars freeVars = freeVars' FreeConf{ fcIgnoreSorts = False }  instance Free Term where   freeVars' conf t = case t of-    Var n ts   -> singleton n `union` freeVars' conf ts+    Var n ts   -> singleton n `union` weakly (freeVars' conf ts)     Lam _ t    -> freeVars' conf t     Lit _      -> empty-    Def _ ts   -> freeVars' conf ts+    Def _ ts   -> weakly $ freeVars' conf ts  -- because we are not in TCM+      -- we cannot query whether we are dealing with a data/record (strongly r.)+      -- or a definition by pattern matching (weakly rigid)+      -- thus, we approximate, losing that x = List x is unsolvable     Con _ ts   -> freeVars' conf ts     Pi a b     -> freeVars' conf (a,b)-    Fun a b    -> freeVars' conf (a,b)     Sort s     -> freeVars' conf s+    Level l    -> freeVars' conf l     MetaV _ ts -> flexible $ freeVars' conf ts-    DontCare   -> empty+    DontCare mt -> irrelevantly $ freeVars' conf mt  instance Free Type where   freeVars' conf (El s t) = freeVars' conf (s, t)@@ -87,16 +154,30 @@     | fcIgnoreSorts conf = empty     | otherwise          = case s of       Type a     -> freeVars' conf a-      Suc s      -> freeVars' conf s-      Lub s1 s2  -> freeVars' conf (s1, s2)       Prop       -> empty       Inf        -> empty-      MetaS _ ts -> flexible $ freeVars' conf ts-      DLub s1 s2 -> freeVars' conf (s1, s2)+      DLub s1 s2 -> weakly $ freeVars' conf (s1, s2) +instance Free Level where+  freeVars' conf (Max as) = freeVars' conf as++instance Free PlusLevel where+  freeVars' conf ClosedLevel{} = empty+  freeVars' conf (Plus _ l)    = freeVars' conf l++instance Free LevelAtom where+  freeVars' conf l = case l of+    MetaLevel _ vs   -> flexible $ freeVars' conf vs+    NeutralLevel v   -> freeVars' conf v+    BlockedLevel _ v -> freeVars' conf v+    UnreducedLevel v -> freeVars' conf v+ instance Free a => Free [a] where-  freeVars' conf xs = unions $ map (freeVars' conf) xs+  freeVars' conf = unions . map (freeVars' conf) +instance Free a => Free (Maybe a) where+  freeVars' conf = maybe empty (freeVars' conf)+ instance (Free a, Free b) => Free (a,b) where   freeVars' conf (x,y) = freeVars' conf x `union` freeVars' conf y @@ -104,7 +185,8 @@   freeVars' conf = freeVars' conf . unArg  instance Free a => Free (Abs a) where-  freeVars' conf (Abs _ b) = mapFV (subtract 1) $ delete 0 $ freeVars' conf b+  freeVars' conf (Abs   _ b) = subtractFV 1 $ delete 0 $ freeVars' conf b+  freeVars' conf (NoAbs _ b) = freeVars' conf b  instance Free a => Free (Tele a) where   freeVars' conf EmptyTel	   = empty@@ -113,7 +195,6 @@ instance Free ClauseBody where   freeVars' conf (Body t)   = freeVars' conf t   freeVars' conf (Bind b)   = freeVars' conf b-  freeVars' conf (NoBind b) = freeVars' conf b   freeVars' conf  NoBody    = empty  freeIn :: Free a => Nat -> a -> Bool@@ -122,3 +203,11 @@ freeInIgnoringSorts :: Free a => Nat -> a -> Bool freeInIgnoringSorts v t =   v `Set.member` allVars (freeVars' FreeConf{ fcIgnoreSorts = True } t)++relevantIn :: Free a => Nat -> a -> Bool+relevantIn v t = v `Set.member` relevantVars (freeVars' FreeConf{ fcIgnoreSorts = True } t)++-- | Is the variable bound by the abstraction actually used?+isBinderUsed :: Free a => Abs a -> Bool+isBinderUsed NoAbs{}   = False+isBinderUsed (Abs _ x) = 0 `freeIn` x

src/full/Agda/TypeChecking/Implicit.hs view

@@ -8,34 +8,38 @@  #include "../undefined.h" import Agda.Utils.Impossible+import Control.Applicative  data ImplicitInsertion-      = ImpInsert Int	  -- ^ this many implicits have to be inserted+      = ImpInsert [Hiding]	  -- ^ this many implicits have to be inserted       | BadImplicits	  -- ^ hidden argument where there should have been a non-hidden arg       | NoSuchName String -- ^ bad named argument       | NoInsertNeeded   deriving (Show) -impInsert :: Int -> ImplicitInsertion-impInsert 0 = NoInsertNeeded-impInsert n = ImpInsert n+impInsert :: [Hiding] -> ImplicitInsertion+impInsert [] = NoInsertNeeded+impInsert hs = ImpInsert hs  -- | The list should be non-empty. insertImplicit :: NamedArg e -> [Arg String] -> ImplicitInsertion insertImplicit _ [] = __IMPOSSIBLE__ insertImplicit a ts | argHiding a == NotHidden = impInsert $ nofHidden ts   where-    nofHidden :: [Arg a] -> Int-    nofHidden = length . takeWhile ((Hidden ==) . argHiding)-insertImplicit a ts@(t : _) =-  case argHiding t of-    NotHidden -> BadImplicits-    Hidden    -> case nameOf (unArg a) of-      Nothing -> impInsert 0-      Just x  -> find 0 x ts+    nofHidden :: [Arg a] -> [Hiding]+    nofHidden = takeWhile (NotHidden /=) . map argHiding+insertImplicit a ts =+  case nameOf (unArg a) of+    Nothing -> maybe BadImplicits impInsert $ upto (argHiding a) $ map argHiding ts+    Just x  -> find [] x (argHiding a) ts   where-    find i x (Arg Hidden r y : ts)-      | x == y	  = impInsert i-      | otherwise = find (i + 1) x ts-    find i x (Arg NotHidden _ _ : _) = NoSuchName x-    find i x []			     = NoSuchName x+    upto h [] = Nothing+    upto h (NotHidden:_) = Nothing+    upto h (h':_) | h == h' = Just []+    upto h (h':hs) = (h':) <$> upto h hs+    find _ x _ (Arg NotHidden _ _ : _) = NoSuchName x+    find hs x hidingx (Arg hidingy r y : ts)+      | x == y && hidingx == hidingy = impInsert $ reverse hs+      | x == y && hidingx /= hidingy = BadImplicits+      | otherwise = find (hidingy:hs) x hidingx ts+    find i x _ []			     = NoSuchName x

src/full/Agda/TypeChecking/Injectivity.hs view

@@ -35,7 +35,9 @@ -- | Reduce simple (single clause) definitions. reduceHead :: Term -> TCM (Blocked Term) reduceHead v = ignoreAbstractMode $ do+  -- first, possibly rewrite literal v to constructor form   v <- constructorForm v+  reportSDoc "tc.inj.reduce" 30 $ text "reduceHead" <+> prettyTCM v   case v of     Def f args -> do       def <- theDef <$> getConstInfo f@@ -67,12 +69,22 @@     Con c _ -> return (Just $ ConHead c)     Sort _  -> return (Just SortHead)     Pi _ _  -> return (Just PiHead)-    Fun _ _ -> return (Just PiHead)     Lit _   -> return Nothing -- handle literal heads as well? can't think of                               -- any examples where it would be useful...     _       -> return Nothing  checkInjectivity :: QName -> [Clause] -> TCM FunctionInverse+checkInjectivity f cs+  | pointLess cs = return NotInjective+  where+    -- Is it pointless to use injectivity for this function?+    pointLess []      = True+    pointLess (_:_:_) = False+    pointLess [Clause{clausePats = ps}] = all (noMatch . unArg) ps+      where noMatch ConP{} = False+            noMatch LitP{} = False+            noMatch VarP{} = True+            noMatch DotP{} = True checkInjectivity f cs = do   reportSLn "tc.inj.check" 40 $ "Checking injectivity of " ++ show f   es <- concat <$> mapM entry cs@@ -97,7 +109,6 @@           h <- headSymbol v           return [(h, c)] -    rhs (NoBind b) = rhs b     rhs (Bind b)   = underAbstraction_ b rhs     rhs (Body v)   = return $ Just v     rhs NoBody     = return Nothing@@ -117,7 +128,7 @@ data InvView = Inv QName Args (Map TermHead Clause)              | NoInv -useInjectivity :: Comparison -> Type -> Term -> Term -> TCM Constraints+useInjectivity :: Comparison -> Type -> Term -> Term -> TCM () useInjectivity cmp a u v = do   uinv <- functionInverse u   vinv <- functionInverse v@@ -133,7 +144,7 @@           , nest 2 $ text "and type" <+> prettyTCM a           ]         pol <- getPolarity' cmp f-        compareArgs pol a fArgs gArgs+        compareArgs pol a (Def f []) fArgs gArgs       | otherwise -> fallBack     (Inv f args inv, NoInv) -> do       a <- defType <$> getConstInfo f@@ -153,11 +164,12 @@       invert v g a inv args =<< headSymbol u     (NoInv, NoInv)          -> fallBack   where-    fallBack = buildConstraint $ ValueCmp cmp a u v+    fallBack = addConstraint $ ValueCmp cmp a u v +    invert :: Term -> QName -> Type -> Map TermHead Clause -> Args -> Maybe TermHead -> TCM ()     invert _ _ a inv args Nothing  = fallBack     invert org f ftype inv args (Just h) = case Map.lookup h inv of-      Nothing                     -> typeError $ UnequalTerms cmp u v a+      Nothing -> typeError $ UnequalTerms cmp u v a       Just (Clause{ clauseTel  = tel                   , clausePerm = perm                   , clausePats = ps }) -> do -- instArgs args ps@@ -186,26 +198,40 @@           -- The clause might not give as many patterns as there           -- are arguments (point-free style definitions).           let args' = take (length margs) args-          cs  <- compareArgs pol ftype margs args'-          unless (null cs) patternViolation+          compareArgs pol ftype org margs args'+{- Andreas, 2011-05-09 allow unsolved constraints as long as progress+          unless (null cs) $ do+            reportSDoc "tc.inj.invert" 30 $+              text "aborting inversion; remaining constraints" <+> prettyTCM cs+            patternViolation+-}           -- Check that we made progress, i.e. the head symbol           -- of the original term should be a constructor.-          h <- headSymbol =<< reduce org+          org <- reduce org+          h <- headSymbol org           case h of             Just h  -> compareTerm cmp a u v-            Nothing -> patternViolation+            Nothing -> do+             reportSDoc "tc.inj.invert" 30 $ vcat+               [ text "aborting inversion;" <+> prettyTCM org+               , text "plainly," <+> text (show org)+               , text "has TermHead" <+> text (show h)+               , text "which does not expose a constructor"+               ]+             patternViolation         `catchError` \err -> case errError err of           TypeError   {} -> throwError err           Exception   {} -> throwError err           IOException {} -> throwError err           PatternErr  {} -> fallBack-          AbortAssign {} -> fallBack+          {- AbortAssign {} -> fallBack -- UNUSED -}      nextMeta = do       m : ms <- get       put ms       return m +    dotP :: Monad m => Term -> StateT [Term] (ReaderT Substitution m) Term     dotP v = do       sub <- ask       return $ substs sub v

+ src/full/Agda/TypeChecking/Irrelevance.hs view

@@ -0,0 +1,161 @@+{-# LANGUAGE CPP #-}++{-| Irrelevant function types.+-}+module Agda.TypeChecking.Irrelevance where++import Control.Applicative+import Control.Monad.Reader++import qualified Data.Map as Map++import Agda.Interaction.Options++import Agda.Syntax.Common++import Agda.TypeChecking.Monad++#include "../undefined.h"+import Agda.Utils.Impossible++-- | data 'Relevance'+--   see 'Agda.Syntax.Common'++-- | @unusableRelevance rel == True@ iff we cannot use a variable of @rel@.+unusableRelevance :: Relevance -> Bool+unusableRelevance rel = NonStrict `moreRelevant` rel++composeRelevance :: Relevance -> Relevance -> Relevance+composeRelevance r r' =+  case (r, r') of+    (Irrelevant, _) -> Irrelevant+    (_, Irrelevant) -> Irrelevant+    (NonStrict, _)  -> NonStrict+    (_, NonStrict)  -> NonStrict+    (Forced, _)     -> Forced+    (_, Forced)     -> Forced+    (Relevant, Relevant) -> Relevant++-- | @inverseComposeRelevance r x@ returns the most irrelevant @y@+--   such that forall @x@, @y@ we have+--   @x `moreRelevant` (r `composeRelevance` y)@+--   iff+--   @(r `inverseComposeRelevance` x) `moreRelevant` y@ (Galois connection).+inverseComposeRelevance :: Relevance -> Relevance -> Relevance+inverseComposeRelevance r x =+  case (r, x) of+    (_, Forced)          -> Forced     -- preserve @Forced@+    (Relevant, x)        -> x          -- going to relevant arg.: nothing changes+    (Forced, Relevant)   -> Forced     -- going forced: relevants become forced+    (Forced, x)          -> x+    (Irrelevant, _)      -> Relevant   -- going irrelevant: every thing usable+    (_, Irrelevant)      -> Irrelevant -- otherwise: irrelevant things remain unusable+    (NonStrict, _)       -> Relevant   -- but @NonStrict@s become usable++-- | For comparing @Relevance@ ignoring @Forced@.+ignoreForced :: Relevance -> Relevance+ignoreForced Forced     = Relevant+ignoreForced Relevant   = Relevant+ignoreForced NonStrict  = NonStrict+ignoreForced Irrelevant = Irrelevant++-- | Irrelevant function arguments may appear non-strictly in the codomain type.+irrToNonStrict :: Relevance -> Relevance+irrToNonStrict Irrelevant = NonStrict+-- irrToNonStrict NonStrict  = Relevant -- TODO: is that what we want (OR: NonStrict)  -- better be more conservative+irrToNonStrict rel        = rel++nonStrictToIrr :: Relevance -> Relevance+nonStrictToIrr NonStrict = Irrelevant+nonStrictToIrr rel       = rel++-- * Operations on 'Arg'.++-- | Prepare parts of a parameter telescope for abstraction in constructors+--   and projections.+hideAndRelParams :: Arg a -> Arg a+hideAndRelParams a = a+  { argRelevance = nonStrictToIrr (argRelevance a)+  , argHiding    = Hidden+  }++-- | @modifyArgRelevance f arg@ applies @f@ to the 'argRelevance' component of @arg@.+modifyArgRelevance :: (Relevance -> Relevance) -> Arg a -> Arg a+modifyArgRelevance f a = a { argRelevance = f (argRelevance a) }++-- | Used to modify context when going into a @rel@ argument.+inverseApplyRelevance :: Relevance -> Arg a -> Arg a+inverseApplyRelevance rel = modifyArgRelevance (rel `inverseComposeRelevance`)+-- inverseApplyRelevance rel a = a { argRelevance = rel `inverseComposeRelevance` argRelevance a }++-- | Compose two relevance flags.+--   This function is used to update the relevance information+--   on pattern variables @a@ after a match against something @rel@.+applyRelevance :: Relevance -> Arg a -> Arg a+applyRelevance rel = modifyArgRelevance (rel `composeRelevance`)+-- applyRelevance rel a = a { argRelevance = rel `composeRelevance` argRelevance a }++{- Andreas, 2011-04-26: the combination Irrelevant Forced does not arise+applyRelevance Irrelevant a | argRelevance a == Relevant =+  a { argRelevance = Irrelevant }+applyRelevance Forced a | argRelevance a == Relevant =+  a { argRelevance = Forced }+applyRelevance rel a = a -- ^ do nothing if rel == Relevant or a is+                         -- already Forced or Irrelevant+-}++-- * Operations on 'Context'.++-- | Modify the context whenever going from the l.h.s. (term side)+--   of the typing judgement to the r.h.s. (type side).+workOnTypes :: TCM a -> TCM a+workOnTypes cont = do+  allowed <- optExperimentalIrrelevance <$> pragmaOptions+  verboseBracket "tc.irr" 20 "workOnTypes" $ workOnTypes' allowed cont++-- | Call me if --experimental-irrelevance is set.+doWorkOnTypes :: TCM a -> TCM a+doWorkOnTypes = verboseBracket "tc.irr" 20 "workOnTypes" . workOnTypes' True++-- | Internal workhorse, expects value of --experimental-irrelevance flag+--   as argument.+workOnTypes' :: Bool -> TCM a -> TCM a+workOnTypes' allowed cont =+  if allowed then+    liftTCM $ modifyContext (modifyContextEntries $ modifyArgRelevance $ irrToNonStrict) cont+   else cont++-- | (Conditionally) wake up irrelevant variables and make them relevant.+--   For instance,+--   in an irrelevant function argument otherwise irrelevant variables+--   may be used, so they are awoken before type checking the argument.+applyRelevanceToContext :: Relevance -> TCM a -> TCM a+applyRelevanceToContext rel =+  case rel of+    Relevant -> id+    Forced   -> id+    _        -> local $ \ e -> e+      { envContext   = modifyContextEntries (inverseApplyRelevance rel) (envContext e)+      , envLetBindings = Map.map+          (fmap $ \ (t, a) -> (t, inverseApplyRelevance rel a))+          (envLetBindings e)+                                                  -- enable local  irr. defs+      , envRelevance = rel                        -- enable global irr. defs+      }++-- | Wake up irrelevant variables and make them relevant.  For instance,+--   in an irrelevant function argument otherwise irrelevant variables+--   may be used, so they are awoken before type checking the argument.+wakeIrrelevantVars :: TCM a -> TCM a+wakeIrrelevantVars = applyRelevanceToContext Irrelevant+{-+wakeIrrelevantVars = local $ \ e -> e+   { envContext = map wakeVar (envContext e) -- enable local  irr. defs+   , envIrrelevant = True                    -- enable global irr. defs+   }+  where wakeVar ce = ce { ctxEntry = makeRelevant (ctxEntry ce) }++applyRelevanceToContext :: Relevance -> TCM a -> TCM a+applyRelevanceToContext Irrelevant cont = wakeIrrelevantVars cont+applyRelevanceToContext _          cont = cont+-}

src/full/Agda/TypeChecking/Level.hs view

@@ -17,56 +17,37 @@ import Agda.Utils.Impossible #include "../undefined.h" -newtype LevelView = Max [PlusView]-  deriving (Show)--data PlusView = ClosedLevel Integer-              | Plus Integer LevelAtom-  deriving (Show, Eq)--data LevelAtom = MetaLevel MetaId Args-             | BlockedLevel Term-             | NeutralLevel Term-  deriving (Show, Eq, Ord)--instance Ord PlusView where-  compare ClosedLevel{} Plus{}            = LT-  compare Plus{} ClosedLevel{}            = GT-  compare (ClosedLevel n) (ClosedLevel m) = compare n m-  compare (Plus n a) (Plus m b)           = compare (a,n) (b,m)-- data LevelKit = LevelKit-  { levelType  :: Term-  , levelSuc   :: Term -> Term-  , levelMax   :: Term -> Term -> Term-  , levelZero  :: Term+  { lvlType  :: Term+  , lvlSuc   :: Term -> Term+  , lvlMax   :: Term -> Term -> Term+  , lvlZero  :: Term   , typeName :: QName   , sucName  :: QName   , maxName  :: QName   , zeroName :: QName   } -levelSucFunction :: MonadTCM tcm => tcm (Term -> Term)+levelSucFunction :: TCM (Term -> Term) levelSucFunction = do   suc <- primLevelSuc   return $ \a -> suc `apply` [defaultArg a] -builtinLevelKit :: MonadTCM tcm => tcm (Maybe LevelKit)+builtinLevelKit :: TCM (Maybe LevelKit) builtinLevelKit = liftTCM $ do     level@(Def l []) <- primLevel-    zero@(Con z []) <- primLevelZero-    suc@(Con s []) <- primLevelSuc+    zero@(Def z []) <- primLevelZero+    suc@(Def s []) <- primLevelSuc     max@(Def m []) <- primLevelMax     let a @@ b = a `apply` [defaultArg b]     return $ Just $ LevelKit-      { levelType = level-      , levelSuc = \a -> suc @@ a-      , levelMax = \a b -> max @@ a @@ b-      , levelZero = zero+      { lvlType  = level+      , lvlSuc   = \a -> suc @@ a+      , lvlMax   = \a b -> max @@ a @@ b+      , lvlZero  = zero       , typeName = l-      , sucName = s-      , maxName = m+      , sucName  = s+      , maxName  = m       , zeroName = z       }   `catchError` \_ -> return Nothing@@ -77,91 +58,76 @@ requireLevels = do   mKit <- builtinLevelKit   case mKit of-    Nothing -> typeError $ GenericError $-      "Some or all of the LEVEL builtins have not been defined."+    Nothing -> sequence_ [primLevel, primLevelZero, primLevelSuc, primLevelMax] >> __IMPOSSIBLE__     Just k  -> return k -unLevelAtom :: LevelAtom -> Term-unLevelAtom (MetaLevel x as) = MetaV x as-unLevelAtom (BlockedLevel a) = a-unLevelAtom (NeutralLevel a) = a--unLevelView :: MonadTCM tcm => LevelView -> tcm Term-unLevelView nv = case nv of-    Max []            -> return $ Lit $ LitLevel noRange 0-    Max [ClosedLevel n] -> return $ Lit $ LitLevel noRange n-    Max [Plus 0 a]    -> return $ unLevelAtom a-    Max [a]           -> do+reallyUnLevelView :: Level -> TCM Term+reallyUnLevelView nv =+  case nv of+    Max []              -> primLevelZero+    Max [Plus 0 a]      -> return $ unLevelAtom a+    Max [a]             -> do+      zer <- primLevelZero       suc <- primLevelSuc-      return $ unPlusV (\n -> suc `apply` [defaultArg n]) a+      return $ unPlusV zer (\n -> suc `apply` [defaultArg n]) a     Max as -> do-      Just LevelKit{ levelSuc = suc, levelMax = max } <- builtinLevelKit-      return $ case map (unPlusV suc) as of+      LevelKit{ lvlZero = zer, lvlSuc = suc, lvlMax = max } <- requireLevels+      return $ case map (unPlusV zer suc) as of         [a] -> a         []  -> __IMPOSSIBLE__         as  -> foldr1 max as   where-    unPlusV suc (ClosedLevel n) = Lit (LitLevel noRange n)-    unPlusV suc (Plus n a)    = foldr (.) id (genericReplicate n suc) (unLevelAtom a)+    unPlusV zer suc (ClosedLevel n) = foldr (.) id (genericReplicate n suc) zer+    unPlusV _   suc (Plus n a)      = foldr (.) id (genericReplicate n suc) (unLevelAtom a) -maybePrimCon :: MonadTCM tcm => TCM Term -> tcm (Maybe QName)+maybePrimCon :: TCM Term -> TCM (Maybe QName) maybePrimCon prim = liftTCM $ do     Con c [] <- prim     return (Just c)   `catchError` \_ -> return Nothing -maybePrimDef :: MonadTCM tcm => TCM Term -> tcm (Maybe QName)+maybePrimDef :: TCM Term -> TCM (Maybe QName) maybePrimDef prim = liftTCM $ do     Def f [] <- prim     return (Just f)   `catchError` \_ -> return Nothing -levelView :: MonadTCM tcm => Term -> tcm LevelView+levelView :: Term -> TCM Level levelView a = do+  reportSLn "tc.level.view" 50 $ "{ levelView " ++ show a   msuc <- maybePrimCon primLevelSuc   mzer <- maybePrimCon primLevelZero   mmax <- maybePrimDef primLevelMax-  let view a =+  let view a = do+        a <- reduce a         case a of+          Level l -> return l           Con s [arg]             | Just s == msuc -> inc <$> view (unArg arg)           Con z []             | Just z == mzer -> return $ closed 0-          Lit (LitLevel _ n)   -> return $ closed n           Def m [arg1, arg2]-            | Just m == mmax -> lub <$> view (unArg arg1) <*> view (unArg arg2)+            | Just m == mmax -> levelLub <$> view (unArg arg1) <*> view (unArg arg2)           _                  -> mkAtom a-  view =<< normalise a+  v <- view a+  reportSLn "tc.level.view" 50 $ "  view: " ++ show v ++ "}"+  return v   where     mkAtom a = do       b <- reduceB a       return $ case b of         NotBlocked (MetaV m as) -> atom $ MetaLevel m as         NotBlocked a            -> atom $ NeutralLevel a-        Blocked _ a             -> atom $ BlockedLevel a+        Blocked m a             -> atom $ BlockedLevel m a      atom a = Max [Plus 0 a] -    closed n = maxim [ClosedLevel n]+    closed n = Max [ClosedLevel n | n > 0]      inc (Max as) = Max $ map inc' as       where         inc' (ClosedLevel n) = ClosedLevel $ n + 1         inc' (Plus n a)    = Plus (n + 1) a -    maxim as = Max $ ns ++ List.sort bs-      where-        ns = case [ n | ClosedLevel n <- as, n > 0 ] of-          []  -> []-          ns  -> [ClosedLevel $ maximum ns]-        bs = subsume [ b | b@Plus{} <- as ]--        subsume (ClosedLevel{} : _) = __IMPOSSIBLE__-        subsume [] = []-        subsume (Plus n a : bs)-          | not $ null ns = subsume bs-          | otherwise     = Plus n a : subsume [ b | b@(Plus _ a') <- bs, a /= a' ]-          where-            ns = [ m | Plus m a'  <- bs, a == a', m > n ]--    lub (Max as) (Max bs) = maxim $ as ++ bs+levelLub :: Level -> Level -> Level+levelLub (Max as) (Max bs) = levelMax $ as ++ bs

+ src/full/Agda/TypeChecking/Level.hs-boot view

@@ -0,0 +1,7 @@++module Agda.TypeChecking.Level where++import Agda.TypeChecking.Monad+import Agda.Syntax.Internal++levelView :: Term -> TCM Level

+ src/full/Agda/TypeChecking/LevelConstraints.hs view

@@ -0,0 +1,34 @@++module Agda.TypeChecking.LevelConstraints ( simplifyLevelConstraint ) where++import Data.List++import Agda.Syntax.Internal+import Agda.TypeChecking.Monad.Base+import Agda.TypeChecking.Substitute+import Agda.Utils.Size++simplifyLevelConstraint :: Integer -> Constraint -> Constraints -> Constraint+simplifyLevelConstraint n new old =+  case inequalities new of+    [a :=< b] | elem (b' :=< a') leqs -> LevelCmp CmpEq (Max [a]) (Max [b])+      where (a', b') = raise (-n) (a, b)+    _ -> new+  where+    leqs = concatMap (inequalities . unClosure) old++    -- Unclosure converts deBruijn indices to deBruijn levels to+    -- enable comparing constraints under different contexts+    unClosure c = raise (-size (envContext $ clEnv cl)) $ clValue cl+      where cl = theConstraint c++data Leq = PlusLevel :=< PlusLevel+  deriving (Show, Eq)++inequalities (LevelCmp CmpEq (Max [a, b]) (Max [c]))+  | a == c = [b :=< a]+  | b == c = [a :=< b]+inequalities (LevelCmp CmpEq (Max [a]) (Max [b, c]))+  | a == b = [c :=< b]+  | a == c = [b :=< c]+inequalities _ = []

src/full/Agda/TypeChecking/MetaVars.hs view

@@ -1,4 +1,4 @@-{-# LANGUAGE CPP, RelaxedPolyRec #-}+{-# LANGUAGE CPP, RelaxedPolyRec, GeneralizedNewtypeDeriving #-}  module Agda.TypeChecking.MetaVars where @@ -6,11 +6,9 @@ import Control.Monad.State import Control.Monad.Error import Data.Generics-import Data.Map (Map)-import Data.Set (Set) import Data.List as List hiding (sort)+import Data.Map (Map) import qualified Data.Map as Map-import qualified Data.Set as Set import qualified Agda.Utils.IO.Locale as LocIO  import Agda.Syntax.Common@@ -29,17 +27,19 @@ import Agda.TypeChecking.Free import Agda.TypeChecking.Records import Agda.TypeChecking.Pretty+import Agda.TypeChecking.Irrelevance import Agda.TypeChecking.EtaContract  import Agda.TypeChecking.MetaVars.Occurs -import {-# SOURCE #-} Agda.TypeChecking.Conversion+import {-# SOURCE #-} Agda.TypeChecking.Conversion -- SOURCE NECESSARY  import Agda.Utils.Fresh import Agda.Utils.List import Agda.Utils.Monad import Agda.Utils.Size import Agda.Utils.Permutation+import qualified Agda.Utils.VarSet as Set  import Agda.TypeChecking.Monad.Debug @@ -55,7 +55,7 @@ findIdx vs v = findIndex (==v) (reverse vs)  -- | Check whether a meta variable is a place holder for a blocked term.-isBlockedTerm :: MonadTCM tcm => MetaId -> tcm Bool+isBlockedTerm :: MetaId -> TCM Bool isBlockedTerm x = do     reportSLn "tc.meta.blocked" 12 $ "is " ++ show x ++ " a blocked term? "     i <- mvInstantiation <$> lookupMeta x@@ -65,109 +65,119 @@ 	    InstV{}                        -> False 	    InstS{}                        -> False 	    Open{}                         -> False+	    OpenIFS{}                      -> False     reportSLn "tc.meta.blocked" 12 $       if r then "  yes, because " ++ show i else "  no"     return r -isEtaExpandable :: MonadTCM tcm => MetaId -> tcm Bool+isEtaExpandable :: MetaId -> TCM Bool isEtaExpandable x = do     i <- mvInstantiation <$> lookupMeta x     return $ case i of       Open{}                         -> True+      OpenIFS{}                      -> False       InstV{}                        -> False       InstS{}                        -> False       BlockedConst{}                 -> False       PostponedTypeCheckingProblem{} -> False -class HasMeta t where-    metaInstance :: MonadTCM tcm => t -> tcm MetaInstantiation-    metaVariable :: MetaId -> Args -> t--instance HasMeta Term where-    metaInstance = return . InstV-    metaVariable = MetaV--instance HasMeta Sort where-    metaInstance = return . InstS . Sort-    metaVariable = MetaS---- TODO-(=:=) :: (MonadTCM tcm) => MetaId -> Term -> tcm ()-x =:= t = do-    reportSLn "tc.meta.assign" 70 $ show x ++ " := " ++ show t-    store <- getMetaStore-    modify $ \st -> st { stMetaStore = ins x (InstS $ killRange t) store }-    etaExpandListeners x-    wakeupConstraints-    reportSLn "tc.meta.assign" 20 $ "completed assignment of " ++ show x-  where-    ins x i store = Map.adjust (inst i) x store-    inst i mv = mv { mvInstantiation = i }+-- * Performing the assignment --- | The instantiation should not be an 'InstV' or 'InstS' and the 'MetaId'+-- | Performing the meta variable assignment.+--+--   The instantiation should not be an 'InstV' or 'InstS' and the 'MetaId' --   should point to something 'Open' or a 'BlockedConst'.-(=:) :: (MonadTCM tcm, HasMeta t, KillRange t, Show t) =>-        MetaId -> t -> tcm ()-x =: t = do+--   Further, the meta variable may not be 'Frozen'.+assignTerm :: MetaId -> Term -> TCM ()+assignTerm x t = do     reportSLn "tc.meta.assign" 70 $ show x ++ " := " ++ show t-    i <- metaInstance (killRange t)-    store <- getMetaStore-    modify $ \st -> st { stMetaStore = ins x i store }+    whenM (isFrozen x) __IMPOSSIBLE__  -- verify (new) invariant+    let i = metaInstance (killRange t)+    verboseS "profile.metas" 10 $ liftTCM $ tickMax "max-open-metas" . size =<< getOpenMetas+    modifyMetaStore $ ins x i     etaExpandListeners x-    wakeupConstraints+    wakeupConstraints x     reportSLn "tc.meta.assign" 20 $ "completed assignment of " ++ show x   where+    metaInstance = InstV     ins x i store = Map.adjust (inst i) x store     inst i mv = mv { mvInstantiation = i } -assignTerm :: MonadTCM tcm => MetaId -> Term -> tcm ()-assignTerm = (=:)--assignSort :: MonadTCM tcm => MetaId -> Sort -> tcm ()-assignSort = (=:)+-- * Creating meta variables. -newSortMeta :: MonadTCM tcm => tcm Sort+newSortMeta :: TCM Sort newSortMeta =   ifM typeInType (return $ mkType 0) $   ifM hasUniversePolymorphism (newSortMetaCtx =<< getContextArgs)+  -- else (no universe polymorphism)   $ do i <- createMetaInfo-       x <- newMeta i normalMetaPriority (idP 0) (IsSort())-       return $ MetaS x []+       x <- newMeta i normalMetaPriority (idP 0) (IsSort () topSort)+       return $ Type $ Max [Plus 0 $ MetaLevel x []] -newSortMetaCtx :: MonadTCM tcm => Args -> tcm Sort+newSortMetaCtx :: Args -> TCM Sort newSortMetaCtx vs =   ifM typeInType (return $ mkType 0) $ do-    i <- createMetaInfo-    x <- newMeta i normalMetaPriority (idP 0) (IsSort ())-    return $ MetaS x vs+    i   <- createMetaInfo+    tel <- getContextTelescope+    let t = telePi_ tel topSort+    x   <- newMeta i normalMetaPriority (idP 0) (IsSort () t)+    reportSDoc "tc.meta.new" 50 $+      text "new sort meta" <+> prettyTCM x <+> text ":" <+> prettyTCM t+    return $ Type $ Max [Plus 0 $ MetaLevel x vs] -newTypeMeta :: MonadTCM tcm => Sort -> tcm Type+newTypeMeta :: Sort -> TCM Type newTypeMeta s = El s <$> newValueMeta (sort s) -newTypeMeta_ ::  MonadTCM tcm => tcm Type-newTypeMeta_  = newTypeMeta =<< newSortMeta+newTypeMeta_ ::  TCM Type+newTypeMeta_  = newTypeMeta =<< (workOnTypes $ newSortMeta)+-- TODO: (this could be made work with new uni-poly)+-- Andreas, 2011-04-27: If a type meta gets solved, than we do not have to check+-- that it has a sort.  The sort comes from the solution.+-- newTypeMeta_  = newTypeMeta Inf +-- | Create a new "implicit from scope" metavariable+newIFSMeta ::  Type -> TCM Term+newIFSMeta t = do+  vs  <- getContextArgs+  tel <- getContextTelescope+  newIFSMetaCtx (telePi_ tel t) vs++-- | Create a new value meta with specific dependencies.+newIFSMetaCtx :: Type -> Args -> TCM Term+newIFSMetaCtx t vs = do+  i <- createMetaInfo+  let TelV tel _ = telView' t+      perm = idP (size tel)+  x <- newMeta' OpenIFS i normalMetaPriority perm (HasType () t)+  reportSDoc "tc.meta.new" 50 $ fsep+    [ text "new ifs meta:"+    , nest 2 $ prettyTCM vs <+> text "|-"+    , nest 2 $ text (show x) <+> text ":" <+> prettyTCM t+    ]+  solveConstraint_ $ FindInScope x+  return (MetaV x vs)+ -- | Create a new metavariable, possibly η-expanding in the process.-newValueMeta ::  MonadTCM tcm => Type -> tcm Term+newValueMeta ::  Type -> TCM Term newValueMeta t = do   vs  <- getContextArgs   tel <- getContextTelescope   newValueMetaCtx (telePi_ tel t) vs -newValueMetaCtx :: MonadTCM tcm => Type -> Args -> tcm Term+newValueMetaCtx :: Type -> Args -> TCM Term newValueMetaCtx t ctx = do   m@(MetaV i _) <- newValueMetaCtx' t ctx   instantiateFull m  -- | Create a new value meta without η-expanding.-newValueMeta' :: MonadTCM tcm => Type -> tcm Term+newValueMeta' :: Type -> TCM Term newValueMeta' t = do   vs  <- getContextArgs   tel <- getContextTelescope   newValueMetaCtx' (telePi_ tel t) vs  -- | Create a new value meta with specific dependencies.-newValueMetaCtx' :: MonadTCM tcm => Type -> Args -> tcm Term+newValueMetaCtx' :: Type -> Args -> TCM Term newValueMetaCtx' t vs = do   i <- createMetaInfo   let TelV tel _ = telView' t@@ -181,47 +191,47 @@   etaExpandMetaSafe x   return $ MetaV x vs -newTelMeta :: MonadTCM tcm => Telescope -> tcm Args+newTelMeta :: Telescope -> TCM Args newTelMeta tel = newArgsMeta (abstract tel $ El Prop $ Sort Prop) -newArgsMeta :: MonadTCM tcm => Type -> tcm Args+newArgsMeta :: Type -> TCM Args newArgsMeta t = do   args <- getContextArgs   tel  <- getContextTelescope   newArgsMetaCtx t tel args -newArgsMetaCtx :: MonadTCM tcm => Type -> Telescope -> Args -> tcm Args+newArgsMetaCtx :: Type -> Telescope -> Args -> TCM Args newArgsMetaCtx (El s tm) tel ctx = do   tm <- reduce tm-  case funView tm of-      FunV (Arg h r a) _  -> do-	  arg  <- (Arg h r) <$>-                   {--                     -- Andreas, 2010-09-24 skip irrelevant record fields when eta-expanding a meta var-                     -- Andreas, 2010-10-11 this is WRONG, see Issue 347-                    if r == Irrelevant then return DontCare else-                    -}-                     newValueMetaCtx (telePi_ tel a) ctx-	  args <- newArgsMetaCtx (El s tm `piApply` [arg]) tel ctx-	  return $ arg : args-      NoFunV _    -> return []+  case tm of+    Pi (Arg h r a) _  -> do+      arg  <- (Arg h r) <$>+               {-+                 -- Andreas, 2010-09-24 skip irrelevant record fields when eta-expanding a meta var+                 -- Andreas, 2010-10-11 this is WRONG, see Issue 347+                if r == Irrelevant then return DontCare else+                -}+                 newValueMetaCtx (telePi_ tel a) ctx+      args <- newArgsMetaCtx (El s tm `piApply` [arg]) tel ctx+      return $ arg : args+    _  -> return []  -- | Create a metavariable of record type. This is actually one metavariable --   for each field.-newRecordMeta :: MonadTCM tcm => QName -> Args -> tcm Term+newRecordMeta :: QName -> Args -> TCM Term newRecordMeta r pars = do   args <- getContextArgs   tel  <- getContextTelescope   newRecordMetaCtx r pars tel args -newRecordMetaCtx :: MonadTCM tcm => QName -> Args -> Telescope -> Args -> tcm Term+newRecordMetaCtx :: QName -> Args -> Telescope -> Args -> TCM Term newRecordMetaCtx r pars tel ctx = do   ftel	 <- flip apply pars <$> getRecordFieldTypes r   fields <- newArgsMetaCtx (telePi_ ftel $ sort Prop) tel ctx   con    <- getRecordConstructor r   return $ Con con fields -newQuestionMark :: MonadTCM tcm => Type -> tcm Term+newQuestionMark :: Type -> TCM Term newQuestionMark t = do   m@(MetaV x _) <- newValueMeta' t   ii		<- fresh@@ -229,31 +239,44 @@   return m  -- | Construct a blocked constant if there are constraints.-blockTerm :: MonadTCM tcm => Type -> Term -> tcm Constraints -> tcm Term-blockTerm t v m = do-    cs <- solveConstraints =<< m-    if List.null cs-	then return v-	else do-	    i	  <- createMetaInfo-	    vs	  <- getContextArgs-	    tel   <- getContextTelescope-	    x	  <- newMeta' (BlockedConst $ abstract tel v)-                              i lowMetaPriority (idP $ size tel)-                              (HasType () $ telePi_ tel t)-			    -- we don't instantiate blocked terms-	    c <- escapeContext (size tel) $ guardConstraint (return cs) (UnBlock x)-            verboseS "tc.meta.blocked" 20 $ do-                dx  <- prettyTCM (MetaV x [])-                dv  <- escapeContext (size tel) $ prettyTCM $ abstract tel v-                dcs <- mapM prettyTCM cs-                liftIO $ LocIO.putStrLn $ "blocked " ++ show dx ++ " := " ++ show dv-                liftIO $ LocIO.putStrLn $ "     by " ++ show dcs-	    addConstraints c-	    return $ MetaV x vs+blockTerm :: Type -> TCM Term -> TCM Term+blockTerm t blocker = do+  (pid, v) <- newProblem blocker+  blockTermOnProblem t v pid --- | Auxiliary function to create a postponed type checking problem.-unblockedTester :: MonadTCM tcm => Type -> tcm Bool+blockTermOnProblem :: Type -> Term -> ProblemId -> TCM Term+blockTermOnProblem t v pid =+  ifM (isProblemSolved pid) (return v) $ do+    i   <- createMetaInfo+    vs  <- getContextArgs+    tel <- getContextTelescope+    x   <- newMeta' (BlockedConst $ abstract tel v)+                    i lowMetaPriority (idP $ size tel)+                    (HasType () $ telePi_ tel t)+                    -- we don't instantiate blocked terms+    escapeContext (size tel) $ addConstraint (Guarded (UnBlock x) pid)+    reportSDoc "tc.meta.blocked" 20 $ vcat+      [ text "blocked" <+> prettyTCM x <+> text ":=" <+> escapeContext (size tel) (prettyTCM $ abstract tel v)+      , text "     by" <+> (prettyTCM =<< getConstraintsForProblem pid) ]+    inst <- isInstantiatedMeta x+    case inst of+      True  -> instantiate (MetaV x vs)+      False -> do+        -- We don't return the blocked term instead create a fresh metavariable+        -- that we compare against the blocked term once it's unblocked. This way+        -- blocked terms can be instantiated before they are unblocked, thus making+        -- constraint solving a bit more robust against instantiation order.+        v   <- newValueMeta t+        i   <- liftTCM (fresh :: TCM Integer)+        -- This constraint is woken up when unblocking, so it doesn't need a problem id.+        cmp <- buildProblemConstraint 0 (ValueCmp CmpEq t v (MetaV x vs))+        listenToMeta (CheckConstraint i cmp) x+        return v++-- | @unblockedTester t@ returns @False@ if @t@ is a meta or a blocked term.+--+--   Auxiliary function to create a postponed type checking problem.+unblockedTester :: Type -> TCM Bool unblockedTester t = do   t <- reduceB $ unEl t   case t of@@ -261,11 +284,17 @@     NotBlocked MetaV{} -> return False     _                  -> return True -postponeTypeCheckingProblem_ :: MonadTCM tcm => A.Expr -> Type -> tcm Term+-- | Create a postponed type checking problem @e : t@ that waits for type @t@+--   to unblock (become instantiated or its constraints resolved).+postponeTypeCheckingProblem_ :: A.Expr -> Type -> TCM Term postponeTypeCheckingProblem_ e t = do   postponeTypeCheckingProblem e t (unblockedTester t) -postponeTypeCheckingProblem :: MonadTCM tcm => A.Expr -> Type -> TCM Bool -> tcm Term+-- | Create a postponed type checking problem @e : t@ that waits for conditon+--   @unblock@.  A new meta is created in the current context that has as+--   instantiation the postponed type checking problem.  An 'UnBlock' constraint+--   is added for this meta, which links to this meta.+postponeTypeCheckingProblem :: A.Expr -> Type -> TCM Bool -> TCM Term postponeTypeCheckingProblem e t unblock = do   i   <- createMetaInfo   tel <- getContextTelescope@@ -273,20 +302,33 @@   m   <- newMeta' (PostponedTypeCheckingProblem cl)                   i normalMetaPriority (idP (size tel))          $ HasType () $ telePi_ tel t-  addConstraints =<< buildConstraint (UnBlock m)-  MetaV m <$> getContextArgs+  -- Create the meta that we actually return+  v   <- newValueMeta t+  i   <- liftTCM (fresh :: TCM Integer)+  vs  <- getContextArgs+  cmp <- buildProblemConstraint 0 (ValueCmp CmpEq t v (MetaV m vs))+  listenToMeta (CheckConstraint i cmp) m+  addConstraint (UnBlock m)+  return v  -- | Eta expand metavariables listening on the current meta.-etaExpandListeners :: MonadTCM tcm => MetaId -> tcm ()+etaExpandListeners :: MetaId -> TCM () etaExpandListeners m = do-  ms <- getMetaListeners m+  ls <- getMetaListeners m   clearMetaListeners m	-- we don't really have to do this+  mapM_ wakeupListener ls++-- | Wake up a meta listener and let it do its thing+wakeupListener :: Listener -> TCM ()   -- Andreas 2010-10-15: do not expand record mvars, lazyness needed for irrelevance-  mapM_ etaExpandMetaSafe ms---  mapM_ (etaExpandMeta allMetaKinds) ms+wakeupListener (EtaExpand x)         = etaExpandMetaSafe x+wakeupListener (CheckConstraint _ c) = do+  reportSDoc "tc.meta.blocked" 20 $ text "waking boxed constraint" <+> prettyTCM c+  addAwakeConstraints [c]+  solveAwakeConstraints  -- | Do safe eta-expansions for meta (@SingletonRecords,Levels@).-etaExpandMetaSafe :: MonadTCM tcm => MetaId -> tcm ()+etaExpandMetaSafe :: MetaId -> TCM () etaExpandMetaSafe = etaExpandMeta [SingletonRecords,Levels]  -- | Various kinds of metavariables.@@ -307,7 +349,7 @@  -- | Eta expand a metavariable, if it is of the specified kind. --   Don't do anything if the metavariable is a blocked term.-etaExpandMeta :: MonadTCM tcm => [MetaKind] -> MetaId -> tcm ()+etaExpandMeta :: [MetaKind] -> MetaId -> TCM () etaExpandMeta kinds m = whenM (isEtaExpandable m) $ do   verboseBracket "tc.meta.eta" 20 ("etaExpandMeta " ++ show m) $ do   meta       <- lookupMeta m@@ -316,10 +358,16 @@   let args	 = [ Arg h r $ Var i [] 		   | (i, Arg h r _) <- reverse $ zip [0..] $ reverse $ telToList tel 		   ]-  bb <- reduceB b+  bb <- reduceB b  -- the target in the type @a@ of @m@   case unEl <$> bb of-    Blocked x _               -> listenToMeta m x-    NotBlocked (MetaV x _)    -> listenToMeta m x+    -- if the target type of @m@ is a meta variable @x@ itself+    -- (@NonBlocked (MetaV{})@),+    -- or it is blocked by a meta-variable @x@ (@Blocked@), we cannot+    -- eta expand now, we have to postpone this.  Once @x@ is+    -- instantiated, we can continue eta-expanding m.  This is realized+    -- by adding @m@ to the listeners of @x@.+    Blocked x _               -> listenToMeta (EtaExpand m) x+    NotBlocked (MetaV x _)    -> listenToMeta (EtaExpand m) x     NotBlocked lvl@(Def r ps) ->       ifM (isEtaRecord r) (do 	let expand = do@@ -328,13 +376,13 @@                 verboseS "tc.meta.eta" 15 $ do                   du <- prettyTCM u                   liftIO $ LocIO.putStrLn $ "eta expanding: " ++ show m ++ " --> " ++ show du-                noConstraints $ assignV b m args u  -- should never produce any constraints+                noConstraints $ assignV m args u  -- should never produce any constraints         if Records `elem` kinds then           expand          else if SingletonRecords `elem` kinds then do           singleton <- isSingletonRecord r ps           case singleton of-            Left x      -> listenToMeta m x+            Left x      -> listenToMeta (EtaExpand m) x             Right False -> return ()             Right True  -> expand          else@@ -345,7 +393,7 @@         if tt && Just lvl == mlvl          then do           reportSLn "tc.meta.eta" 20 $ "Expanding level meta to 0 (type-in-type)"-          noConstraints $ assignV b m args (Lit $ LitLevel noRange 0)+          noConstraints $ assignV m args (Level $ Max [])          else           return ()     _ -> return ()@@ -353,8 +401,7 @@ -- | Eta expand blocking metavariables of record type, and reduce the -- blocked thing. -etaExpandBlocked-  :: (MonadTCM tcm, Reduce t) => Blocked t -> tcm (Blocked t)+etaExpandBlocked :: Reduce t => Blocked t -> TCM (Blocked t) etaExpandBlocked t@NotBlocked{} = return t etaExpandBlocked (Blocked m t)  = do   etaExpandMeta [Records] m@@ -363,163 +410,139 @@     Blocked m' _ | m /= m' -> etaExpandBlocked t     _                      -> return t -abortAssign :: MonadTCM tcm => tcm a-abortAssign =-    do	s <- get-	liftTCM $ throwError $ TCErr Nothing $ AbortAssign s--handleAbort :: MonadTCM tcm => TCM a -> TCM a -> tcm a-handleAbort h m = liftTCM $-    m `catchError_` \e ->-	case errError e of-	    AbortAssign s -> do put s; h-            PatternErr{}  -> do-              -- Andreas, 2010-09-17 uncommenting the reportSLn statements-              -- breaks something.  Why?-              -- reportSLn "tc.meta.assign" 50 "handleAbort: Pattern violation!"-              throwError e-	    _		  -> do-              -- reportSLn "tc.meta.assign" 50 "handleAbort: Some exception"-              throwError e+-- * Solve constraint @x vs = v@. --- | Assign to an open metavar.+-- | Assign to an open metavar which may not be frozen. --   First check that metavar args are in pattern fragment. --     Then do extended occurs check on given thing. ---assignV :: MonadTCM tcm => Type -> MetaId -> Args -> Term -> tcm Constraints-assignV t x args v =-    handleAbort handler $ do+--   Assignment is aborted by throwing a @PatternErr@ via a call to+--   @patternViolation@.  This error is caught by @catchConstraint@+--   during equality checking (@compareAtom@) and leads to+--   restoration of the original constraints.++assignV :: MetaId -> Args -> Term -> TCM ()+assignV x args v = do 	reportSDoc "tc.meta.assign" 10 $ do 	  text "term" <+> prettyTCM (MetaV x args) <+> text ":=" <+> prettyTCM v+        liftTCM $ nowSolvingConstraints (assign x args v) `finally` solveAwakeConstraints -        v <- normalise v-        case v of-          Sort Inf  -> typeError $ GenericError "Setω is not a valid type."-          _         -> return ()+-- | @assign sort? x vs v@+assign :: MetaId -> Args -> Term -> TCM ()+assign x args v = do+        mvar <- lookupMeta x  -- information associated with meta x -	-- We don't instantiate blocked terms-	whenM (isBlockedTerm x) patternViolation	-- TODO: not so nice+        -- Andreas, 2011-05-20 TODO!+        -- full normalization  (which also happens during occurs check)+        -- is too expensive! (see Issue 415)+        -- need to do something cheaper, especially if+        -- we are dealing with a Miller pattern that can be solved+        -- immediately!+        -- Ulf, 2011-08-25 DONE!+        -- Just instantiating the top-level meta, which is cheaper. The occurs+        -- check will first try without unfolding any definitions (treating+        -- arguments to definitions as flexible), if that fails it tries again+        -- with full unfolding.+        v <- instantiate v+        reportSLn "tc.meta.assign" 50 $ "MetaVars.assign: assigning to " ++ show v -	-- Check that the arguments are distinct variables-        -- Andreas, 2010-09-24: Herein, ignore the variables which are not-        -- free in v-        let fvs = allVars $ freeVars v+        case (v, mvJudgement mvar) of+            (Sort Inf, HasType{}) -> typeError $ GenericError "Setω is not a valid type."+            _                     -> return ()++        -- We don't instantiate frozen mvars+        when (mvFrozen mvar == Frozen) $ do+          reportSLn "tc.meta.assign" 25 $ "aborting: meta is frozen!"+          patternViolation++	-- We never get blocked terms here anymore. TODO: we actually do. why?+	whenM (isBlockedTerm x) patternViolation++        -- Andreas, 2010-10-15 I want to see whether rhs is blocked+        reportSLn "tc.meta.assign" 50 $ "MetaVars.assign: I want to see whether rhs is blocked"+        reportSDoc "tc.meta.assign" 25 $ do+          v0 <- reduceB v+          case v0 of+            Blocked m0 _ -> text "r.h.s. blocked on:" <+> prettyTCM m0+            NotBlocked{} -> text "r.h.s. not blocked"++        -- Normalise and eta contract the arguments to the meta. These are+        -- usually small, and simplifying might let us instantiate more metas.+        args <- etaContract =<< normalise args++        -- Andreas, 2011-04-21 do the occurs check first+        -- e.g. _1 x (suc x) = suc (_2 x y)+        -- even though the lhs is not a pattern, we can prune the y from _2+        let varsL = freeVars args+        let relVL = Set.toList $ relevantVars varsL+        -- Andreas, 2011-10-06 only irrelevant vars that are direct+        -- arguments to the meta, hence, can be abstracted over, may+        -- appear on the rhs.  (test/fail/Issue483b)+        -- let irrVL = Set.toList $ irrelevantVars varsL+        let fromIrrVar (Arg h Irrelevant (Var i [])) = [i]+            fromIrrVar (Arg h Irrelevant (DontCare (Var i []))) = [i]+            fromIrrVar _ = []+        let irrVL = concat $ map fromIrrVar args         reportSDoc "tc.meta.assign" 20 $             let pr (Var n []) = text (show n)                 pr (Def c []) = prettyTCM c+                pr (DontCare v) = pr v                 pr _          = text ".."             in vcat                  [ text "mvar args:" <+> sep (map (pr . unArg) args)-                 , text "fvars rhs:" <+> sep (map (text . show) $ Set.toList fvs)+                 , text "fvars lhs (rel):" <+> sep (map (text . show) relVL)+                 , text "fvars lhs (irr):" <+> sep (map (text . show) irrVL)                  ]-	ids <- checkArgs x args fvs -	reportSDoc "tc.meta.assign" 15 $-	    text "preparing to instantiate: " <+> prettyTCM v--        -- Andreas, 2010-10-15 I want to see whether rhd is blocked-        reportSDoc "tc.meta.assign" 25 $ do-          v0 <- reduceB v-          case v0 of-            Blocked m0 _ -> text "blocked on:" <+> prettyTCM m0-            NotBlocked{} -> text "not blocked"--	-- Check that the x doesn't occur in the right hand side-	v <- liftTCM $ occursCheck x (map unArg ids) v+	-- Check that the x doesn't occur in the right hand side.+        -- Prune mvars on rhs such that they can only depend on varsL.+        -- Herein, distinguish relevant and irrelevant vars,+        -- since when abstracting irrelevant lhs vars, they may only occur+        -- irrelevantly on rhs.+	v <- liftTCM $ occursCheck x (relVL, irrVL) v -	verboseS "tc.conv.assign" 30 $ do+	reportSLn "tc.meta.assign" 15 "passed occursCheck"+	verboseS "tc.meta.assign" 30 $ do 	  let n = size v 	  when (n > 200) $ do-	    r <- getMetaRange x 	    d <- sep [ text "size" <+> text (show n)-		     , nest 2 $ text "type" <+> prettyTCM t+--		     , nest 2 $ text "type" <+> prettyTCM t 		     , nest 2 $ text "term" <+> prettyTCM v 		     ] 	    liftIO $ LocIO.print d -	reportSLn "tc.meta.assign" 15 "passed occursCheck"--	-- Rename the variables in v to make it suitable for abstraction over ids.-	v' <- do-	    -- Basically, if-	    --   Γ   = a b c d e-	    --   ids = d b e-	    -- then-	    --   v' = (λ a b c d e. v) _ 1 _ 2 0-	    tel  <- getContextTelescope-	    args <- map defaultArg <$> getContextTerms-	    let iargs = reverse $ zipWith (rename $ reverse $ map unArg ids) [0..] $ reverse args-		v'    = raise (size ids) (abstract tel v) `apply` iargs-	    return v'--	let extTel (Arg h r i) m = do-	      tel <- m-	      t	  <- typeOfBV i-	      x	  <- nameOfBV i-	      return $ ExtendTel (Arg h r t) (Abs (show x) tel)-	tel' <- foldr extTel (return EmptyTel) ids--	reportSDoc "tc.meta.assign" 15 $-	  text "final instantiation:" <+> prettyTCM (abstract tel' v')--	-- Perform the assignment (and wake constraints). Metas-	-- are top-level so we do the assignment at top-level.-	n <- size <$> getContextTelescope-	escapeContext n $ x =: killRange (abstract tel' v')-	return []-    where-	rename ids i arg = case findIndex (==i) ids of-	    Just j  -> fmap (const $ Var (fromIntegral j) []) arg-	    Nothing -> fmap (const __IMPOSSIBLE__) arg	-- we will end up here, but never look at the result--	handler :: MonadTCM tcm => tcm Constraints-	handler = do-	    reportSLn "tc.meta.assign" 10 $ "Oops. Undo " ++ show x ++ " := ..."-	    equalTerm t (MetaV x args) v---- TODO: Unify with assignV-assignS :: MonadTCM tcm => MetaId -> Args -> Sort -> tcm Constraints-assignS x args s =-  ifM (not <$> hasUniversePolymorphism) (noPolyAssign x s) $-    handleAbort handler $ do-	reportSDoc "tc.meta.assign" 10 $ do-	  text "sort" <+> prettyTCM (MetaS x args) <+> text ":=" <+> prettyTCM s--	-- We don't instantiate blocked terms-	whenM (isBlockedTerm x) patternViolation	-- TODO: not so nice+	-- Check that the arguments are variables+	ids <- checkAllVars args -	-- Check that the arguments are distinct variables+        -- Check linearity of @ids@+        -- Andreas, 2010-09-24: Herein, ignore the variables which are not+        -- free in v+        -- Ulf, 2011-09-22: we need to respect irrelevant vars as well, otherwise+        -- we'll build solutions where the irrelevant terms are not valid+        let fvs = allVars $ freeVars v         reportSDoc "tc.meta.assign" 20 $-            let pr (Var n []) = text (show n)-                pr (Def c []) = prettyTCM c-                pr _          = text ".."-            in-            text "args:" <+> sep (map (pr . unArg) args)--        -- TODO Hack-        let fvs = freeVars s-        when (any (< 0) $ Set.toList (flexibleVars fvs)) $ do-            reportSLn "tc.meta.assign" 10 "negative variables!"-            patternViolation--	ids <- checkArgs x args (allVars fvs)--	reportSDoc "tc.meta.assign" 15 $-	    text "preparing to instantiate: " <+> prettyTCM s+          text "fvars rhs:" <+> sep (map (text . show) $ Set.toList fvs) -	-- Check that the x doesn't occur in the right hand side-	v <- liftTCM $ occursCheck x (map unArg ids) (Sort s)+        unless (distinct $ filter (`Set.member` fvs) ids) $ do+          -- non-linear lhs: we cannot solve, but prune+          killResult <- prune x args $ Set.toList fvs+          reportSDoc "tc.meta.assign" 10 $+            text "pruning" <+> prettyTCM x <+> (text $+              if killResult `elem` [PrunedSomething,PrunedEverything] then "succeeded"+               else "failed")+          patternViolation -	verboseS "tc.conv.assign" 30 $ do-	  let n = size v-	  when (n > 200) $ do-	    r <- getMetaRange x-	    d <- sep [ text "size" <+> text (show n)-		     , nest 2 $ text "sort" <+> prettyTCM v-		     ]-	    liftIO $ LocIO.print d+{- Andreas, 2011-04-21 this does not work+        if not (distinct $ filter (`Set.member` fvs) ids) then do+          -- non-linear lhs: we cannot solve, but prune+          ok <- prune x args $ Set.toList fvs+          if ok then return [] else patternViolation -	reportSLn "tc.meta.assign" 15 "passed occursCheck"+        else do+-}+        -- we are linear, so we can solve!+	reportSDoc "tc.meta.assign" 25 $+	    text "preparing to instantiate: " <+> prettyTCM v  	-- Rename the variables in v to make it suitable for abstraction over ids. 	v' <- do@@ -528,90 +551,84 @@ 	    --   ids = d b e 	    -- then 	    --   v' = (λ a b c d e. v) _ 1 _ 2 0-	    tel  <- getContextTelescope-	    args <- map defaultArg <$> getContextTerms-	    let iargs = reverse $ zipWith (rename $ reverse $ map unArg ids) [0..] $ reverse args-		v'    = raise (size ids) (abstract tel v) `apply` iargs+	    tel   <- getContextTelescope+	    gamma <- map defaultArg <$> getContextTerms+	    let iargs = reverse $ zipWith (rename ids) [0..] $ reverse gamma+		v'    = raise (size args) (abstract tel v) `apply` iargs 	    return v' -	let extTel (Arg h r i) m = do-	      tel <- m-	      t	  <- typeOfBV i-	      x	  <- nameOfBV i-	      return $ ExtendTel (Arg h r t) (Abs (show x) tel)-	tel' <- foldr extTel (return EmptyTel) ids+        -- Andreas, 2011-04-18 to work with irrelevant parameters DontCare+        -- we need to construct tel' from the type of the meta variable+        -- (no longer from ids which may not be the complete variable list+        -- any more)+        let t = jMetaType $ mvJudgement mvar+	reportSDoc "tc.meta.assign" 15 $ text "type of meta =" <+> prettyTCM t+--	reportSDoc "tc.meta.assign" 30 $ text "type of meta =" <+> text (show t) -	reportSDoc "tc.meta.assign" 15 $-	  text "final instantiation:" <+> prettyTCM (abstract tel' v')+        TelV tel0 core0 <- telViewM t+        let n = length args+	reportSDoc "tc.meta.assign" 30 $ text "tel0  =" <+> prettyTCM tel0+	reportSDoc "tc.meta.assign" 30 $ text "#args =" <+> text (show n)+        when (size tel0 < n) __IMPOSSIBLE__+        let tel' = telFromList $ take n $ telToList tel0 +	reportSDoc "tc.meta.assign" 10 $+	  text "solving" <+> prettyTCM x <+> text ":=" <+> prettyTCM (abstract tel' v')+ 	-- Perform the assignment (and wake constraints). Metas 	-- are top-level so we do the assignment at top-level. 	n <- size <$> getContextTelescope-	escapeContext n $ x =:= killRange (abstract tel' v')-	return []+	escapeContext n $ assignTerm x $ killRange (abstract tel' v')+	return ()     where+        -- @ids@ are the lhs variables (metavar arguments)+        -- @i@ is the variable from the context Gamma+        rename :: [Nat] -> Nat -> Arg Term -> Arg Term 	rename ids i arg = case findIndex (==i) ids of 	    Just j  -> fmap (const $ Var (fromIntegral j) []) arg-	    Nothing -> fmap (const __IMPOSSIBLE__) arg-              -- we will end up here, but never look at the result--	handler :: MonadTCM tcm => tcm Constraints-	handler = do-	    reportSLn "tc.meta.assign" 10 $ "Oops. Undo " ++ show x ++ " := ..."-	    equalSort (MetaS x args) s--        noPolyAssign x s =-          handleAbort (equalSort (MetaS x []) s) $ do-            Sort s <- occursCheck x [] (Sort s)-            x =: s-            return []+	    Nothing -> fmap (const __IMPOSSIBLE__) arg	-- we will end up here, but never look at the result -type FVs = Set Nat+type FVs = Set.VarSet  -- | Check that arguments to a metavar are in pattern fragment. --   Assumes all arguments already in whnf. --   Parameters are represented as @Var@s so @checkArgs@ really---     checks that all args are unique @Var@s and returns the---     list of corresponding indices for each arg-- done---     to not define equality on @Term@.+--     checks that all args are @Var@s and returns the+--     list of corresponding indices for each arg.+--   Linearity has to be checked separately. -- --   @reverse@ is necessary because we are directly abstracting over this list @ids@.----checkArgs :: MonadTCM tcm => MetaId -> Args -> FVs -> tcm [Arg Nat]-checkArgs x args fvs = do-  args <- instantiateFull args-  case validParameters args fvs of-    Just ids -> return $ reverse ids-    Nothing  -> patternViolation---- | Check that the parameters to a meta variable are distinct variables.--- Andreas, 2010-09-24: Allow non-linear variables that do not appear in @FVs@.-validParameters :: Monad m => Args -> FVs -> m [Arg Nat]-validParameters args fvs-    | all isVar args && distinct (filter (flip Set.member fvs) $ map unArg vars)-                = return $ reverse vars-    | otherwise	= fail "invalid parameters"-    where-	vars = [ Arg h r i | Arg h r (Var i []) <- args ]-+checkAllVars :: Args -> TCM [Nat]+checkAllVars args =+  case allVarOrIrrelevant args of+    Nothing -> do+      reportSDoc "tc.meta.assign" 15 $ vcat [ text "not all variables: " <+> prettyTCM args+                                            , text "  aborting assignment" ]+      patternViolation+    Just is -> return $ map unArg is -isVar :: Arg Term -> Bool-isVar (Arg _ _ (Var _ [])) = True-isVar _			 = False+-- | filter out irrelevant args and check that all others are variables.+--   Return the reversed list of variables.+allVarOrIrrelevant :: Args -> Maybe [Arg Nat]+allVarOrIrrelevant args = foldM isVarOrIrrelevant [] args where+  isVarOrIrrelevant vars arg =+    case arg of+      Arg h r (Var i []) -> return $ Arg h r i : removeIrr i vars+      Arg h Irrelevant (DontCare (Var i [])) -> return $ addIrrIfNotPresent h i vars+      -- Andreas, 2011-04-27 keep irrelevant variables+      Arg h Irrelevant _ -> return $ Arg h Irrelevant (-1) : vars -- any impossible deBruijn index will do (see Jason Reed, LFMTP 09 "_" or Nipkow "minus infinity")+      _                  -> Nothing+  -- in case of non-linearity make sure not to count the irrelevant vars+  addIrrIfNotPresent h i vars+    | any (\ (Arg _ _ j) -> j == i) vars = Arg h Irrelevant (-1) : vars+    | otherwise                          = Arg h Irrelevant i    : vars+  removeIrr i = map (\ a@(Arg h r j) ->+    if r == Irrelevant && i == j then Arg h Irrelevant (-1) else a)  -updateMeta :: (MonadTCM tcm, Data a, Occurs a, Abstract a) => MetaId -> a -> tcm ()-updateMeta mI t =-    do	mv <- lookupMeta mI-	withMetaInfo (getMetaInfo mv) $-	    do	args <- getContextArgs-		cs <- upd mI args (mvJudgement mv) t-		unless (List.null cs) $ fail $ "failed to update meta " ++ show mI-    where-	upd mI args j t = (__IMPOSSIBLE__ `mkQ` updV j `extQ` updS) t-	    where-		updV (HasType _ t) v =-		  assignV (t `piApply` args) mI args v-		updV _ _	     = __IMPOSSIBLE__--		updS s = assignS mI args s+updateMeta :: MetaId -> Term -> TCM ()+updateMeta mI v = do+    mv <- lookupMeta mI+    withMetaInfo (getMetaInfo mv) $ do+      args <- getContextArgs+      noConstraints $ assignV mI args v

src/full/Agda/TypeChecking/MetaVars.hs-boot view

@@ -1,10 +1,9 @@  module Agda.TypeChecking.MetaVars where -import Agda.Syntax.Internal	       ( MetaId, Term, Sort )-import Agda.TypeChecking.Monad.Base ( MonadTCM )--assignTerm :: MonadTCM tcm => MetaId -> Term -> tcm ()-assignSort :: MonadTCM tcm => MetaId -> Sort -> tcm ()+import Agda.Syntax.Internal	    ( MetaId, Term, Sort, Type, Args )+import Agda.TypeChecking.Monad.Base ( TCM ) -etaExpandMetaSafe :: MonadTCM tcm => MetaId -> tcm ()+assignTerm        :: MetaId -> Term -> TCM ()+etaExpandMetaSafe :: MetaId -> TCM ()+assignV           :: MetaId -> Args -> Term -> TCM ()

+ src/full/Agda/TypeChecking/MetaVars/Mention.hs view

@@ -0,0 +1,105 @@++module Agda.TypeChecking.MetaVars.Mention where++import Data.Traversable++import Agda.Syntax.Common+import Agda.Syntax.Internal+import Agda.TypeChecking.Reduce+import Agda.TypeChecking.Monad+++class MentionsMeta t where+  mentionsMeta :: MetaId -> t -> Bool++instance MentionsMeta Term where+  mentionsMeta x v = case v of+    Var _ args   -> mm args+    Lam _ b      -> mm b+    Lit{}        -> False+    Def _ args   -> mm args+    Con _ args   -> mm args+    Pi a b       -> mm (a, b)+    Sort s       -> mm s+    Level l      -> mm l+    DontCare v   -> False   -- we don't have to look inside don't cares when deciding to wake constraints+    MetaV y args -> x == y || mm args   -- TODO: we really only have to look one level deep at meta args+    where+      mm v = mentionsMeta x v++instance MentionsMeta Level where+  mentionsMeta x (Max as) = mentionsMeta x as++instance MentionsMeta PlusLevel where+  mentionsMeta x ClosedLevel{} = False+  mentionsMeta x (Plus _ a) = mentionsMeta x a++instance MentionsMeta LevelAtom where+  mentionsMeta x l = case l of+    MetaLevel m vs   -> x == m || mentionsMeta x vs+    BlockedLevel m _ -> x == m    -- if it's blocked on a different meta it doesn't matter if it mentions the meta somewhere else+    UnreducedLevel l -> mentionsMeta x l+    NeutralLevel l   -> mentionsMeta x l++instance MentionsMeta Type where+    mentionsMeta x (El s t) = mentionsMeta x (s, t)++instance MentionsMeta Sort where+  mentionsMeta x s = case s of+    Type l     -> mentionsMeta x l+    Prop       -> False+    Inf        -> False+    DLub s1 s2 -> mentionsMeta x (s1, s2)++instance MentionsMeta t => MentionsMeta (Abs t) where+  mentionsMeta x = mentionsMeta x . unAbs++instance MentionsMeta t => MentionsMeta (Arg t) where+  mentionsMeta x = mentionsMeta x . unArg++instance MentionsMeta t => MentionsMeta [t] where+  mentionsMeta x = any (mentionsMeta x)++instance MentionsMeta t => MentionsMeta (Maybe t) where+  mentionsMeta x = maybe False (mentionsMeta x)++instance (MentionsMeta a, MentionsMeta b) => MentionsMeta (a, b) where+  mentionsMeta x (a, b) = mentionsMeta x a || mentionsMeta x b++instance (MentionsMeta a, MentionsMeta b, MentionsMeta c) => MentionsMeta (a, b, c) where+  mentionsMeta x (a, b, c) = mentionsMeta x a || mentionsMeta x b || mentionsMeta x c++instance MentionsMeta a => MentionsMeta (Closure a) where+  mentionsMeta x cl = mentionsMeta x (clValue cl)++instance MentionsMeta Elim where+  mentionsMeta x Proj{} = False+  mentionsMeta x (Apply v) = mentionsMeta x v++instance MentionsMeta a => MentionsMeta (Tele a) where+  mentionsMeta x EmptyTel = False+  mentionsMeta x (ExtendTel a b) = mentionsMeta x (a, b)++instance MentionsMeta ProblemConstraint where+  mentionsMeta x = mentionsMeta x . theConstraint++instance MentionsMeta Constraint where+  mentionsMeta x c = case c of+    ValueCmp _ t u v    -> mm (t, u, v)+    ElimCmp _ t v as bs -> mm ((t, v), (as, bs))+    LevelCmp _ u v      -> mm (u, v)+    TypeCmp _ a b       -> mm (a, b)+    TelCmp a b _ u v    -> mm ((a, b), (u, v))+    SortCmp _ a b       -> mm (a, b)+    Guarded c _         -> mm c+    UnBlock _           -> True   -- this might be a postponed typechecking+                                  -- problem and we don't have a handle on+                                  -- what metas it depends on+    FindInScope m       -> True   -- this needs to be woken up for any meta+    IsEmpty t           -> mm t+    where+      mm v = mentionsMeta x v++-- instance (Ord k, MentionsMeta e) => MentionsMeta (Map k e) where+--   mentionsMeta = traverse mentionsMeta+

src/full/Agda/TypeChecking/MetaVars/Occurs.hs view

@@ -5,77 +5,125 @@ import Control.Applicative import Control.Monad import Control.Monad.Error-import qualified Data.Set as Set+import Data.Traversable (traverse)  import Agda.Syntax.Common import Agda.Syntax.Internal import Agda.TypeChecking.Monad import Agda.TypeChecking.Reduce import Agda.TypeChecking.Pretty-import Agda.TypeChecking.Free+import Agda.TypeChecking.Free hiding (Occurrence(..)) import Agda.TypeChecking.Substitute import Agda.TypeChecking.EtaContract+import Agda.TypeChecking.Datatypes (isDataOrRecordType) import {-# SOURCE #-} Agda.TypeChecking.MetaVars  import Agda.Utils.Monad import Agda.Utils.Permutation import Agda.Utils.Size+import qualified Agda.Utils.VarSet as Set  import Agda.Utils.Impossible #include "../../undefined.h" -data OccursCtx = Flex | Rigid+data OccursCtx+  = Flex          -- ^ we are in arguments of a meta+  | Rigid         -- ^ we are not in arguments of a meta but a bound var+  | StronglyRigid -- ^ we are at the start or in the arguments of a constructor+  | Irrel         -- ^ we are in an irrelevant argument   deriving (Eq, Show) +data UnfoldStrategy = YesUnfold | NoUnfold+  deriving (Eq, Show)++defArgs :: UnfoldStrategy -> OccursCtx -> OccursCtx+defArgs NoUnfold  _   = Flex+defArgs YesUnfold ctx = weakly ctx++unfold :: UnfoldStrategy -> Term -> TCM (Blocked Term)+unfold NoUnfold  v = NotBlocked <$> instantiate v+unfold YesUnfold v = reduceB v++-- | Leave the strongly rigid position.+weakly :: OccursCtx -> OccursCtx+weakly StronglyRigid = Rigid+weakly ctx = ctx++strongly :: OccursCtx -> OccursCtx+strongly Rigid = StronglyRigid+strongly ctx = ctx+ abort :: OccursCtx -> TypeError -> TCM ()-abort Flex  _   = patternViolation-abort Rigid err = typeError err+abort StronglyRigid err = typeError err -- here, throw an uncatchable error (unsolvable constraint)+abort Flex  _ = patternViolation -- throws a PatternErr, which leads to delayed constraint+abort Rigid _ = patternViolation+abort Irrel _ = patternViolation +-- | Distinguish relevant and irrelevant variables in occurs check.+type Vars = ([Nat],[Nat])++goIrrelevant :: Vars -> Vars+goIrrelevant (relVs, irrVs) = (irrVs ++ relVs, [])++allowedVar :: Nat -> Vars -> Bool+allowedVar i (relVs, irrVs) = i `elem` relVs++takeRelevant :: Vars -> [Nat]+takeRelevant = fst++underAbs :: Vars -> Vars+underAbs (relVs, irrVs) = (0 : map (1+) relVs, map (1+) irrVs)+ -- | Extended occurs check. class Occurs t where-  occurs :: OccursCtx -> MetaId -> [Nat] -> t -> TCM t+  occurs :: UnfoldStrategy -> OccursCtx -> MetaId -> Vars -> t -> TCM t  -- | When assigning @m xs := v@, check that @m@ does not occur in @v@ --   and that the free variables of @v@ are contained in @xs@.-occursCheck :: MonadTCM tcm => MetaId -> [Nat] -> Term -> tcm Term+occursCheck :: MetaId -> Vars -> Term -> TCM Term occursCheck m xs v = liftTCM $ do-  v <- instantiate v-  case v of-    -- Don't fail if trying to instantiate to just itself-    MetaV m' _        | m == m' -> patternViolation-    Sort (MetaS m' _) | m == m' -> patternViolation-    _                           ->-                              -- Produce nicer error messages-      occurs Rigid m xs v `catchError` \err -> case errError err of-        TypeError _ cl -> case clValue cl of-          MetaOccursInItself{} ->-            typeError . GenericError . show =<<-              fsep [ text ("Refuse to construct infinite term by instantiating " ++ show m ++ " to")-                   , prettyTCM v-                   ]-          MetaCannotDependOn _ _ i ->-            ifM ((&&) <$> isSortMeta m <*> (not <$> hasUniversePolymorphism))-            ( typeError . GenericError . show =<<-              fsep [ text ("Cannot instantiate the metavariable " ++ show m ++ " to")-                   , prettyTCM v-                   , text "since universe polymorphism is not enabled"-                   , text "(use the --universe-polymorphism flag to enable)"-                   ]-            )-            ( typeError . GenericError . show =<<-              fsep [ text ("Cannot instantiate the metavariable " ++ show m ++ " to")-                   , prettyTCM v-                   , text "since it contains the variable"-                   , enterClosure cl $ \_ -> prettyTCM (Var i [])-                   , text $ "which " ++ show m ++ " cannot depend on"-                   ]-            )-          _ -> throwError err-        _ -> throwError err+  let bailOnSelf v = do+        v <- instantiate v+        case v of+          -- Don't fail if trying to instantiate to just itself+          MetaV m' _ | m == m' -> patternViolation+          Level (Max [Plus 0 (MetaLevel m' _)])+                     | m == m' -> patternViolation+          _ -> return v +  v <- bailOnSelf v+  -- First try without normalising the term+  occurs NoUnfold  StronglyRigid m xs v `catchError` \_ -> do+  occurs YesUnfold StronglyRigid m xs v `catchError` \err -> case errError err of+                          -- Produce nicer error messages+    TypeError _ cl -> case clValue cl of+      MetaOccursInItself{} ->+        typeError . GenericError . show =<<+          fsep [ text ("Refuse to construct infinite term by instantiating " ++ show m ++ " to")+               , prettyTCM =<< instantiateFull v+               ]+      MetaCannotDependOn _ _ i ->+        ifM ((&&) <$> isSortMeta m <*> (not <$> hasUniversePolymorphism))+        ( typeError . GenericError . show =<<+          fsep [ text ("Cannot instantiate the metavariable " ++ show m ++ " to")+               , prettyTCM v+               , text "since universe polymorphism is disabled"+               ]+        )+        ( typeError . GenericError . show =<<+            fsep [ text ("Cannot instantiate the metavariable " ++ show m ++ " to solution")+                 , prettyTCM v+                 , text "since it contains the variable"+                 , enterClosure cl $ \_ -> prettyTCM (Var i [])+                 , text $ "which is not in scope of the metavariable or irrelevant in the metavariable but relevant in the solution"+                 ]+          )+      _ -> throwError err+    _ -> throwError err+ instance Occurs Term where-  occurs ctx m xs v = do-    v <- reduceB v+  occurs red ctx m xs v = do+    v <- unfold red v     case v of       -- Don't fail on blocked terms or metas       Blocked _ v  -> occurs' Flex v@@ -83,30 +131,35 @@     where       occurs' ctx v = case v of         Var i vs   -> do         -- abort Rigid turns this error into PatternErr-          unless (i `elem` xs) $ abort ctx $ MetaCannotDependOn m xs i-          Var i <$> occ vs-        Lam h f	    -> Lam h <$> occ f+          unless (i `allowedVar` xs) $ abort (strongly ctx) $ MetaCannotDependOn m (takeRelevant xs) i+          Var i <$> occ (weakly ctx) vs+        Lam h f	    -> Lam h <$> occ ctx f+        Level l     -> Level <$> occ ctx l         Lit l	    -> return v-        DontCare    -> return v-        Def c vs    -> Def c <$> occ vs-        Con c vs    -> Con c <$> occ vs-        Pi a b	    -> uncurry Pi <$> occ (a,b)-        Fun a b	    -> uncurry Fun <$> occ (a,b)-        Sort s	    -> Sort <$> occ s+        DontCare v  -> DontCare <$> occurs red Irrel m (goIrrelevant xs) v+        Def d vs    -> Def d <$> occDef d ctx vs+        Con c vs    -> Con c <$> occ ctx vs  -- if strongly rigid, remain so+        Pi a b	    -> uncurry Pi <$> occ ctx (a,b)+        Sort s	    -> Sort <$> occ ctx s         MetaV m' vs -> do             -- Check for loop-            when (m == m') $ abort ctx $ MetaOccursInItself m+            --   don't fail hard on this, since we might still be on the top-level+            --   after some killing (Issue 442)+            when (m == m') $ patternViolation -            -- The arguments are in a flexible position-            (MetaV m' <$> occurs Flex m xs vs) `catchError` \err -> do+            -- The arguments of a meta are in a flexible position+            (MetaV m' <$> occurs red Flex m xs vs) `catchError` \err -> do               reportSDoc "tc.meta.kill" 25 $ vcat                 [ text $ "error during flexible occurs check, we are " ++ show ctx                 , text $ show (errError err)                 ]               case errError err of                 -- On pattern violations try to remove offending-                -- flexible occurrences (if in a rigid context)-                PatternErr{} | ctx == Rigid -> do+                -- flexible occurrences (if not already in a flexible context)+                PatternErr{} | ctx /= Flex -> do+                      reportSLn "tc.meta.kill" 20 $+                        "oops, pattern violation for " ++ show m'+{-                   let kills = map (hasBadRigid xs) $ map unArg vs                   reportSLn "tc.meta.kill" 20 $                     "oops, pattern violation for " ++ show m' ++ "\n" ++@@ -124,76 +177,161 @@                           ]                         ]                       ok <- killArgs kills m'-                      if ok-                        then occurs Rigid m xs =<< instantiate (MetaV m' vs)+-}+                      killResult <- prune m' vs (takeRelevant xs)+                      if (killResult == PrunedEverything)+                        -- after successful pruning, restart occurs check+                        then occurs red ctx m xs =<< instantiate (MetaV m' vs)                         else throwError err                 _ -> throwError err         where-          occ x = occurs ctx m xs x+          occ ctx v = occurs red ctx m xs v+          -- a data or record type constructor propagates strong occurrences+          -- since e.g. x = List x is unsolvable+          occDef d ctx v = ifM (isDataOrRecordType d) (occ ctx v)+                                 (occ (defArgs red ctx) v) +instance Occurs Level where+  occurs red ctx m xs (Max as) = Max <$> occurs red ctx m xs as++instance Occurs PlusLevel where+  occurs red ctx m xs l@ClosedLevel{} = return l+  occurs red ctx m xs (Plus n l) = Plus n <$> occurs red ctx m xs l++instance Occurs LevelAtom where+  occurs red ctx m xs l = do+    l <- case red of+           YesUnfold -> reduce l+           NoUnfold  -> instantiate l+    case l of+      MetaLevel m' args -> do+        MetaV m' args <- occurs red ctx m xs (MetaV m' args)+        return $ MetaLevel m' args+      NeutralLevel v   -> NeutralLevel   <$> occurs red ctx m xs v+      BlockedLevel m v -> BlockedLevel m <$> occurs red Flex m xs v+      UnreducedLevel v -> UnreducedLevel <$> occurs red ctx m xs v+ instance Occurs Type where-  occurs ctx m xs (El s v) = uncurry El <$> occurs ctx m xs (s,v)+  occurs red ctx m xs (El s v) = uncurry El <$> occurs red ctx m xs (s,v)  instance Occurs Sort where-  occurs ctx m xs s = do-    s' <- reduce s+  occurs red ctx m xs s = do+    s' <- case red of+            YesUnfold -> reduce s+            NoUnfold  -> instantiate s     case s' of-      MetaS m' args -> do-        when (m == m') $ abort ctx $ MetaOccursInItself m-        MetaS m' <$> occurs Flex m xs args-      Lub s1 s2  -> uncurry Lub <$> occurs ctx m xs (s1,s2)-      DLub s1 s2 -> uncurry DLub <$> occurs ctx m xs (s1, s2)-      Suc s      -> Suc <$> occurs ctx m xs s-      Type a     -> Type <$> occurs ctx m xs a+      DLub s1 s2 -> uncurry DLub <$> occurs red (weakly ctx) m xs (s1,s2)+      Type a     -> Type <$> occurs red ctx m xs a       Prop       -> return s'       Inf        -> return s'  instance Occurs a => Occurs (Abs a) where-  occurs ctx m xs (Abs s x) = Abs s <$> occurs ctx m (0 : map (1+) xs) x+  occurs red ctx m xs (Abs   s x) = Abs   s <$> occurs red ctx m (underAbs xs) x+  occurs red ctx m xs (NoAbs s x) = NoAbs s <$> occurs red ctx m xs x  instance Occurs a => Occurs (Arg a) where-  occurs ctx m xs (Arg h r x) = Arg h r <$> occurs ctx m xs x+  occurs red ctx m xs (Arg h r x) = Arg h r <$> occurs red ctx m xs x  instance (Occurs a, Occurs b) => Occurs (a,b) where-  occurs ctx m xs (x,y) = (,) <$> occurs ctx m xs x <*> occurs ctx m xs y+  occurs red ctx m xs (x,y) = (,) <$> occurs red ctx m xs x <*> occurs red ctx m xs y  instance Occurs a => Occurs [a] where-  occurs ctx m xs ys = mapM (occurs ctx m xs) ys+  occurs red ctx m xs ys = mapM (occurs red ctx m xs) ys --- Getting rid of flexible occurrences --+-- * Getting rid of flexible occurrences +-- | @prune m' vs xs@ attempts to remove all arguments from @vs@ whose+--   free variables are not contained in @xs@.+--   If successful, @m'@ is solved by the new, pruned meta variable and we+--   return @True@ else @False@.+prune :: MetaId -> Args -> [Nat] -> TCM PruneResult+prune m' vs xs = liftTCM $ do+  let kills = map (hasBadRigid xs) $ map unArg vs+  reportSDoc "tc.meta.kill" 10 $ vcat+    [ text "attempting kills"+    , nest 2 $ vcat+      [ text "m'    =" <+> text (show m')+      , text "xs    =" <+> text (show xs)+      , text "vs    =" <+> prettyList (map prettyTCM vs)+      , text "kills =" <+> text (show kills)+      ]+    ]+{- Andreas, 2011-05-11 REDUNDANT CODE+  reportSLn "tc.meta.kill" 20 $+    "attempting to prune meta " ++ show m' ++ "\n" +++    "  kills: " ++ show kills+  if not (or kills)+    then return False -- nothing to kill+    else do+-}+  killArgs kills m'++-- | @hasBadRigid xs v = True@ iff one of the rigid variables in @v@ is not in @xs@.+--   Actually we can only prune if a bad variable is in the head. See issue 458. hasBadRigid :: [Nat] -> Term -> Bool-hasBadRigid xs v =-  not $ Set.isSubsetOf-    (rigidVars $ freeVars v)-    (Set.fromList xs)+hasBadRigid xs (Var v _) = notElem v xs+hasBadRigid xs _         = False+  -- not $ Set.isSubsetOf+  --   (rigidVars $ freeVars v)+  --   (Set.fromList xs) -killArgs :: [Bool] -> MetaId -> TCM Bool+data PruneResult+  = NothingToPrune   -- ^ the kill list is empty or only @False@s+  | PrunedNothing    -- ^ there is no possible kill (because of type dep.)+  | PrunedSomething  -- ^ managed to kill some args in the list+  | PrunedEverything -- ^ all prescribed kills where performed+    deriving (Eq, Show)++-- | @killArgs [k1,...,kn] X@ prunes argument @i@ from metavar @X@ if @ki==True@.+--   Pruning is carried out whenever > 0 arguments can be pruned.+--   @True@ is only returned if all arguments could be pruned.+killArgs :: [Bool] -> MetaId -> TCM PruneResult killArgs kills _-  | not (or kills) = return False  -- nothing to kill+  | not (or kills) = return NothingToPrune  -- nothing to kill killArgs kills m = do   mv <- lookupMeta m+  if mvFrozen mv == Frozen then return PrunedNothing else do+{- Andreas 2011-04-26, allow pruning in MetaS   case mvJudgement mv of     IsSort _    -> return False     HasType _ a -> do+-}+      let a = jMetaType $ mvJudgement mv       TelV tel b <- telView' <$> instantiateFull a       let args         = zip (telToList tel) (kills ++ repeat False)           (kills', a') = killedType args b       dbg kills' a a'-      when (any unArg kills') $ performKill (reverse kills') m a'-      -- Only successful if all occurrences were killed-      return (map unArg kills' == kills)+      -- If there is any prunable argument, perform the pruning+      if not (any unArg kills') then return PrunedNothing else do+        performKill (reverse kills') m a'+        -- Only successful if all occurrences were killed+        -- Andreas, 2011-05-09 more precisely, check that at least+        -- the in 'kills' prescribed kills were carried out+        -- OLD CODE: return (map unArg kills' == kills)+        return $ if (and $ zipWith implies kills $ map unArg kills')+                   then PrunedEverything+                   else PrunedSomething   where+    implies :: Bool -> Bool -> Bool+    implies False _ = True+    implies True  x = x     dbg kills' a a' =       reportSDoc "tc.meta.kill" 10 $ vcat         [ text "after kill analysis"         , nest 2 $ vcat-          [ text "kills'  =" <+> text (show kills')+          [ text "metavar =" <+> prettyTCM m+          , text "kills   =" <+> text (show kills)+          , text "kills'  =" <+> text (show kills')           , text "oldType =" <+> prettyTCM a           , text "newType =" <+> prettyTCM a'           ]         ] +-- | @killedType [((x1,a1),k1)..((xn,an),kn)] b = ([k'1..k'n],t')@+--   (ignoring @Arg@).  Let @t' = (xs:as) -> b@.+--   Invariant: @k'i == True@ iff @ki == True@ and pruning the @i@th argument from+--   type @b@ is possible without creating unbound variables.+--   @t'@ is type @t@ after pruning all @k'i==True@. killedType :: [(Arg (String, Type), Bool)] -> Type -> ([Arg Bool], Type) killedType [] b = ([], b) killedType ((arg, kill) : kills) b@@ -208,9 +346,11 @@ performKill :: [Arg Bool] -> MetaId -> Type -> TCM () performKill kills m a = do   mv <- lookupMeta m+  when (mvFrozen mv == Frozen) __IMPOSSIBLE__   let perm = Perm (size kills)              [ i | (i, Arg _ _ False) <- zip [0..] (reverse kills) ]-  m' <- newMeta (mvInfo mv) (mvPriority mv) perm (HasType undefined a)+  m' <- newMeta (mvInfo mv) (mvPriority mv) perm+                (HasType __IMPOSSIBLE__ a)   -- Andreas, 2010-10-15 eta expand new meta variable if necessary   etaExpandMetaSafe m'   let vars = reverse [ Arg h r (Var i []) | (i, Arg h r False) <- zip [0..] kills ]

src/full/Agda/TypeChecking/Monad/Base.hs view

@@ -1,20 +1,24 @@ {-# LANGUAGE CPP, ExistentialQuantification, FlexibleContexts, Rank2Types,              TypeSynonymInstances, MultiParamTypeClasses, FlexibleInstances,-             UndecidableInstances, DeriveDataTypeable, GeneralizedNewtypeDeriving+             UndecidableInstances, DeriveDataTypeable, GeneralizedNewtypeDeriving,+             DeriveFunctor, DeriveFoldable, DeriveTraversable   #-} module Agda.TypeChecking.Monad.Base where +import Control.Arrow import Control.Exception as E import Control.Monad.Error import Control.Monad.State import Control.Monad.Reader import Control.Applicative+import Data.Function import Data.Int import Data.Map as Map import Data.Set as Set import Data.Generics import Data.Foldable import Data.Traversable+import Data.IORef import System.Time  import Agda.Syntax.Common@@ -33,10 +37,13 @@ import qualified Agda.Interaction.Highlighting.Range as R import Agda.Interaction.Highlighting.Precise (HighlightingInfo) +import qualified Agda.Compiler.JS.Syntax as JS+ import Agda.Utils.FileName import Agda.Utils.Fresh import Agda.Utils.Monad import Agda.Utils.Permutation+import Agda.Utils.Pretty  #include "../../undefined.h" import Agda.Utils.Impossible@@ -49,37 +56,47 @@     TCSt { stFreshThings       :: FreshThings 	 , stMetaStore	       :: MetaStore 	 , stInteractionPoints :: InteractionPoints-	 , stConstraints       :: Constraints+	 , stAwakeConstraints    :: Constraints+	 , stSleepingConstraints :: Constraints 	 , stSignature	       :: Signature 	 , stImports	       :: Signature 	 , stImportedModules   :: Set ModuleName          , stModuleToSource    :: ModuleToSource 	 , stVisitedModules    :: VisitedModules-	 , stDecodedModules    :: DecodedModules          , stCurrentModule     :: Maybe ModuleName            -- ^ The current module is available after it has been type            -- checked. 	 , stScope	       :: ScopeInfo-	 , stPersistentOptions :: CommandLineOptions-           -- ^ Options which apply to all files, unless overridden. 	 , stPragmaOptions     :: PragmaOptions            -- ^ Options applying to the current file. @OPTIONS@            -- pragmas only affect this field. 	 , stStatistics	       :: Statistics+         , stExtLambdaTele     :: Map QName (Int , Int) 	 , stMutualBlocks      :: Map MutualId (Set QName) 	 , stLocalBuiltins     :: BuiltinThings PrimFun          , stImportedBuiltins  :: BuiltinThings PrimFun          , stHaskellImports    :: Set String            -- ^ Imports that should be generated by the compiler (this            -- includes imports from imported modules).+         , stPersistent        :: PersistentTCState 	 } +-- | A part of the state which is not reverted when an error is thrown+-- or the state is reset.++data PersistentTCState = PersistentTCSt+  { stDecodedModules    :: DecodedModules+  , stPersistentOptions :: CommandLineOptions+    -- ^ Options which apply to all files, unless overridden.+  }+ data FreshThings = 	Fresh { fMeta	     :: MetaId 	      , fInteraction :: InteractionId 	      , fMutual	     :: MutualId 	      , fName	     :: NameId 	      , fCtx	     :: CtxId+              , fProblem     :: ProblemId               , fInteger     :: Integer                 -- ^ Can be used for various things. 	      }@@ -87,25 +104,29 @@  initState :: TCState initState =-    TCSt { stFreshThings       = Fresh 0 0 0 (NameId 0 0) 0 0+    TCSt { stFreshThings       = (Fresh 0 0 0 (NameId 0 0) 0 0 0) { fProblem = 1 } 	 , stMetaStore	       = Map.empty 	 , stInteractionPoints = Map.empty-	 , stConstraints       = []+	 , stAwakeConstraints    = []+	 , stSleepingConstraints = [] 	 , stSignature	       = emptySignature 	 , stImports	       = emptySignature 	 , stImportedModules   = Set.empty          , stModuleToSource    = Map.empty 	 , stVisitedModules    = Map.empty-	 , stDecodedModules    = Map.empty          , stCurrentModule     = Nothing 	 , stScope	       = emptyScopeInfo-	 , stPersistentOptions = defaultOptions 	 , stPragmaOptions     = optPragmaOptions $ defaultOptions 	 , stStatistics	       = Map.empty+         , stExtLambdaTele     = Map.empty 	 , stMutualBlocks      = Map.empty 	 , stLocalBuiltins     = Map.empty 	 , stImportedBuiltins  = Map.empty          , stHaskellImports    = Set.empty+         , stPersistent        = PersistentTCSt+           { stPersistentOptions = defaultOptions+	   , stDecodedModules    = Map.empty+           } 	 }  stBuiltinThings :: TCState -> BuiltinThings PrimFun@@ -141,6 +162,16 @@ 	where 	    i = fInteger s +newtype ProblemId = ProblemId Nat+  deriving (Typeable, Data, Eq, Ord, Enum, Real, Integral, Num)++instance Show ProblemId where+  show (ProblemId n) = show n++instance HasFresh ProblemId FreshThings where+  nextFresh s = (i, s { fProblem = succ i })+    where i = fProblem s+ instance HasFresh i FreshThings => HasFresh i TCState where     nextFresh s = ((,) $! i) $! s { stFreshThings = f } 	where@@ -204,8 +235,8 @@ instance HasRange a => HasRange (Closure a) where     getRange = getRange . clValue -buildClosure :: MonadTCM tcm => a -> tcm (Closure a)-buildClosure x = liftTCM $ do+buildClosure :: a -> TCM (Closure a)+buildClosure x = do     env   <- ask     sig   <- gets stSignature     scope <- gets stScope@@ -215,56 +246,52 @@ -- ** Constraints --------------------------------------------------------------------------- -type ConstraintClosure = Closure Constraint+type Constraints = [ProblemConstraint] -data Constraint = ValueCmp Comparison Type Term Term-                | ArgsCmp [Polarity] Type Args Args-		| TypeCmp Comparison Type Type-                | TelCmp Comparison Telescope Telescope-		| SortCmp Comparison Sort Sort-                | LevelCmp Comparison Term Term-		| UnBlock MetaId-		| Guarded Constraint Constraints-                | IsEmpty Type+data ProblemConstraint = PConstr+  { constraintProblem :: ProblemId+  , theConstraint     :: Closure Constraint+  }   deriving (Typeable, Show) +data Constraint+  = ValueCmp Comparison Type Term Term+  | ElimCmp [Polarity] Type Term [Elim] [Elim]+  | TypeCmp Comparison Type Type+  | TelCmp Type Type Comparison Telescope Telescope -- ^ the two types are for the error message only+  | SortCmp Comparison Sort Sort+  | LevelCmp Comparison Level Level+  | UnBlock MetaId+  | Guarded Constraint ProblemId+  | IsEmpty Type+  | FindInScope MetaId+  deriving (Typeable, Show)+ data Comparison = CmpEq | CmpLeq   deriving (Eq, Typeable, Show) -type Constraints = [ConstraintClosure]- --------------------------------------------------------------------------- -- * Open things ---------------------------------------------------------------------------  -- | A thing tagged with the context it came from. data Open a = OpenThing [CtxId] a-    deriving (Typeable, Data, Show)+    deriving (Typeable, Data, Show, Functor)  --------------------------------------------------------------------------- -- * Judgements+--+-- Used exclusively for typing of meta variables. ---------------------------------------------------------------------------  data Judgement t a-	= HasType a t-	| IsSort  a-    deriving (Typeable, Data)+	= HasType { jMetaId :: a, jMetaType :: t }+	| IsSort  { jMetaId :: a, jMetaType :: t } -- Andreas, 2011-04-26: type needed for higher-order sort metas+    deriving (Typeable, Data, Functor, Foldable, Traversable)  instance (Show t, Show a) => Show (Judgement t a) where     show (HasType a t) = show a ++ " : " ++ show t-    show (IsSort  a)   = show a ++ " sort"--instance Functor (Judgement t) where-    fmap f (HasType x t) = HasType (f x) t-    fmap f (IsSort  x)	 = IsSort (f x)--instance Foldable (Judgement t) where-    foldr f z (HasType x _) = f x z-    foldr f z (IsSort  x)   = f x z--instance Traversable (Judgement t) where-    traverse f (HasType x t) = flip HasType t <$> f x-    traverse f (IsSort  x)   = IsSort <$> f x+    show (IsSort  a t) = show a ++ " :sort " ++ show t  --------------------------------------------------------------------------- -- ** Meta variables@@ -279,15 +306,41 @@                   --   ones it does not depend on 		, mvJudgement	  :: Judgement Type MetaId 		, mvInstantiation :: MetaInstantiation-		, mvListeners	  :: Set MetaId	  -- ^ metavariables interested in what happens to this guy+		, mvListeners	  :: Set Listener -- ^ meta variables scheduled for eta-expansion but blocked by this one+                , mvFrozen        :: Frozen -- ^ are we past the point where we can instantiate this meta variable? 		}     deriving (Typeable) +data Listener = EtaExpand MetaId+              | CheckConstraint Nat ProblemConstraint+  deriving (Typeable)++instance Eq Listener where+  EtaExpand       x   == EtaExpand       y   = x == y+  CheckConstraint x _ == CheckConstraint y _ = x == y+  _ == _ = False++instance Ord Listener where+  EtaExpand       x   `compare` EtaExpand       y   = x `compare` y+  CheckConstraint x _ `compare` CheckConstraint y _ = x `compare` y+  EtaExpand{} `compare` CheckConstraint{} = LT+  CheckConstraint{} `compare` EtaExpand{} = Prelude.GT++-- | Frozen meta variable cannot be instantiated by unification.+--   This serves to prevent the completion of a definition by its use+--   outside of the current block.+--   (See issues 118, 288, 399).+data Frozen+  = Frozen        -- ^ Do not instantiate.+  | Instantiable+    deriving (Eq, Show)+ data MetaInstantiation-	= InstV Term-	| InstS Term  -- should be Lam .. Sort s-	| Open-	| BlockedConst Term+	= InstV Term         -- ^ solved by term+	| InstS Term         -- ^ solved by @Lam .. Sort s@+	| Open               -- ^ unsolved+	| OpenIFS            -- ^ open, to be instantiated as "implicit from scope"+	| BlockedConst Term  -- ^ solution blocked by unsolved constraints         | PostponedTypeCheckingProblem (Closure (A.Expr, Type, TCM Bool))     deriving (Typeable) @@ -295,6 +348,7 @@   show (InstV t) = "InstV (" ++ show t ++ ")"   show (InstS s) = "InstS (" ++ show s ++ ")"   show Open      = "Open"+  show OpenIFS   = "OpenIFS"   show (BlockedConst t) = "BlockedConst (" ++ show t ++ ")"   show (PostponedTypeCheckingProblem{}) = "PostponedTypeCheckingProblem (...)" @@ -310,8 +364,8 @@     getRange m = getRange $ getMetaInfo m  instance SetRange MetaVariable where-  setRange r (MetaVar mi p perm j inst ls) =-    MetaVar (mi {clValue = r}) p perm j inst ls+  setRange r (MetaVar mi p perm j inst ls frozen) =+    MetaVar (mi {clValue = r}) p perm j inst ls frozen  normalMetaPriority :: MetaPriority normalMetaPriority = MetaPriority 0@@ -385,6 +439,9 @@   deriving (Typeable, Data, Show)  data DisplayTerm = DWithApp [DisplayTerm] Args+                 | DCon QName [Arg DisplayTerm]+                 | DDef QName [Arg DisplayTerm]+                 | DDot Term 		 | DTerm Term   deriving (Typeable, Data, Show) @@ -392,18 +449,20 @@ defaultDisplayForm c = []  data Definition = Defn-  { defRelevance :: Relevance -- ^ Some defs can be irrelevant (but not hidden).-  , defName      :: QName-  , defType      :: Type	      -- ^ Type of the lifted definition.-  , defDisplay   :: [Open DisplayForm]-  , defMutual    :: MutualId-  , theDef	 :: Defn+  { defRelevance   :: Relevance -- ^ Some defs can be irrelevant (but not hidden).+  , defName        :: QName+  , defType        :: Type	      -- ^ Type of the lifted definition.+  , defDisplay     :: [Open DisplayForm]+  , defMutual      :: MutualId+  , defCompiledRep :: CompiledRepresentation+  , theDef         :: Defn   }     deriving (Typeable, Data, Show)  type HaskellCode = String type HaskellType = String type EpicCode    = String+type JSCode      = JS.Exp  data HaskellRepresentation       = HsDefn HaskellType HaskellCode@@ -413,17 +472,24 @@ data Polarity = Covariant | Contravariant | Invariant   deriving (Typeable, Data, Show, Eq) +data CompiledRepresentation = CompiledRep+  { compiledHaskell :: Maybe HaskellRepresentation+  , compiledEpic    :: Maybe EpicCode+  , compiledJS      :: Maybe JSCode+  }+  deriving (Typeable, Data, Show)++noCompiledRep :: CompiledRepresentation+noCompiledRep = CompiledRep Nothing Nothing Nothing+ -- | 'Positive' means strictly positive and 'Negative' means not strictly -- positive. data Occurrence = Positive | Negative | Unused   deriving (Typeable, Data, Show, Eq, Ord)  data Defn = Axiom-            { axHsDef   :: Maybe HaskellRepresentation-            , axEpDef   :: Maybe EpicCode-            } 	  | Function-            { funClauses        :: [Clauses]+            { funClauses        :: [Clause]             , funCompiled       :: CompiledClauses             , funInv            :: FunctionInverse             , funPolarity       :: [Polarity]@@ -431,12 +497,15 @@             , funAbstr          :: IsAbstract             , funDelayed        :: Delayed               -- ^ Are the clauses of this definition delayed?-            , funProjection     :: Maybe Int+            , funProjection     :: Maybe (QName, Int)               -- ^ Is it a record projection?-              --   If yes, then return the index of the record argument.-              --   Start counting with 1, because 0 means that it is already-              --   applied to the record. (Can happen in module instantiation.)-              --   This information is used in the termination checker.+              --   If yes, then return the name of the record type and index of+              --   the record argument.  Start counting with 1, because 0 means that+              --   it is already applied to the record. (Can happen in module+              --   instantiation.) This information is used in the termination+              --   checker.+            , funStatic         :: Bool+              -- ^ Should calls to this function be normalised at compile-time?             } 	  | Datatype             { dataPars           :: Nat           -- nof parameters@@ -447,7 +516,6 @@             , dataSort           :: Sort             , dataPolarity       :: [Polarity]             , dataArgOccurrences :: [Occurrence]-            , dataHsType         :: Maybe HaskellType             , dataAbstr          :: IsAbstract             } 	  | Record@@ -457,7 +525,7 @@             , recNamedCon       :: Bool             , recConType        :: Type                 -- ^ The record constructor's type.             , recFields         :: [Arg A.QName]-            , recTel            :: Telescope+            , recTel            :: Telescope            -- ^ The record field telescope             , recPolarity       :: [Polarity]             , recArgOccurrences :: [Occurrence]             , recEtaEquality    :: Bool@@ -467,20 +535,18 @@             { conPars   :: Nat         -- nof parameters 	    , conSrcCon :: QName       -- original constructor (this might be in a module instance) 	    , conData   :: QName       -- name of datatype or record type-            , conHsCode :: Maybe (HaskellType, HaskellCode) -- used by the compiler 	    , conAbstr  :: IsAbstract             , conInd    :: Induction   -- ^ Inductive or coinductive?             }-            -- ^ Note that, currently, the sharp constructor is-            --   represented as a definition ('Def'), but if you look-            --   up the name you will get a @Constructor@. 	  | Primitive             { primAbstr :: IsAbstract             , primName  :: String-            , primClauses :: Maybe [Clauses]+            , primClauses :: Maybe [Clause]               -- ^ 'Nothing' for primitive functions, @'Just'               -- something@ for builtin functions.             , primCompiled :: Maybe CompiledClauses+              -- ^ 'Nothing' for primitive functions, @'Just'+              -- something@ for builtin functions.             }             -- ^ Primitive or builtin functions.     deriving (Typeable, Data, Show)@@ -493,37 +559,39 @@   deriving (Typeable, Data)  data Reduced no yes = NoReduction no | YesReduction yes-    deriving (Typeable)+    deriving (Typeable, Functor)  data IsReduced = NotReduced | Reduced (Blocked ()) data MaybeReduced a = MaybeRed   { isReduced     :: IsReduced   , ignoreReduced :: a   }--instance Functor MaybeReduced where-  fmap f (MaybeRed r x) = MaybeRed r (f x)+  deriving (Functor)  type MaybeReducedArgs = [MaybeReduced (Arg Term)]  notReduced :: a -> MaybeReduced a notReduced x = MaybeRed NotReduced x -reduced :: Blocked a -> MaybeReduced a-reduced b = MaybeRed (Reduced $ fmap (const ()) b) (ignoreBlocking b)+reduced :: Blocked (Arg Term) -> MaybeReduced (Arg Term)+reduced b = case b of+  NotBlocked (Arg _ _ (MetaV x _)) -> MaybeRed (Reduced $ Blocked x ()) v+  _                                -> MaybeRed (Reduced $ () <$ b)      v+  where+    v = ignoreBlocking b  data PrimFun = PrimFun 	{ primFunName		:: QName 	, primFunArity		:: Arity-	, primFunImplementation :: MonadTCM tcm => [Arg Term] -> tcm (Reduced MaybeReducedArgs Term)+	, primFunImplementation :: [Arg Term] -> TCM (Reduced MaybeReducedArgs Term) 	}     deriving (Typeable) -defClauses :: Definition -> [Clauses]+defClauses :: Definition -> [Clause] defClauses Defn{theDef = Function{funClauses = cs}}        = cs defClauses Defn{theDef = Primitive{primClauses = Just cs}} = cs-defClauses Defn{theDef = Datatype{dataClause = Just c}}    = [Clauses Nothing c]-defClauses Defn{theDef = Record{recClause = Just c}}       = [Clauses Nothing c]+defClauses Defn{theDef = Datatype{dataClause = Just c}}    = [c]+defClauses Defn{theDef = Record{recClause = Just c}}       = [c] defClauses _                                               = []  defCompiled :: Definition -> Maybe CompiledClauses@@ -531,6 +599,12 @@ defCompiled Defn{theDef = Primitive{primCompiled = mcc}} = mcc defCompiled _ = Nothing +defJSDef :: Definition -> Maybe JSCode+defJSDef = compiledJS . defCompiledRep++defEpicDef :: Definition -> Maybe EpicCode+defEpicDef = compiledEpic . defCompiledRep+ -- | Used to specify whether something should be delayed. data Delayed = Delayed | NotDelayed   deriving (Typeable, Data, Show, Eq)@@ -542,14 +616,13 @@  defAbstract :: Definition -> IsAbstract defAbstract d = case theDef d of-    Axiom{}                   -> AbstractDef+    Axiom{}                   -> ConcreteDef     Function{funAbstr = a}    -> a     Datatype{dataAbstr = a}   -> a     Record{recAbstr = a}      -> a     Constructor{conAbstr = a} -> a     Primitive{primAbstr = a}  -> a - --------------------------------------------------------------------------- -- ** Injectivity ---------------------------------------------------------------------------@@ -574,7 +647,7 @@ -- ** Statistics --------------------------------------------------------------------------- -type Statistics = Map String Int+type Statistics = Map String Integer  --------------------------------------------------------------------------- -- ** Trace@@ -591,18 +664,19 @@ 	  | IsType_ A.Expr (Maybe Type) 	  | InferVar Name (Maybe (Term, Type)) 	  | InferDef Range QName (Maybe (Term, Type))-	  | CheckArguments Range [NamedArg A.Expr] Type Type (Maybe (Args, Type, Constraints))+	  | CheckArguments Range [NamedArg A.Expr] Type Type (Maybe (Args, Type)) 	  | CheckDataDef Range Name [A.LamBinding] [A.Constructor] (Maybe ()) 	  | CheckRecDef Range Name [A.LamBinding] [A.Constructor] (Maybe ()) 	  | CheckConstructor QName Telescope Sort A.Constructor (Maybe ()) 	  | CheckFunDef Range Name [A.Clause] (Maybe ()) 	  | CheckPragma Range A.Pragma (Maybe ()) 	  | CheckPrimitive Range Name A.Expr (Maybe ())-          | CheckSectionApplication Range ModuleName A.Telescope ModuleName [NamedArg A.Expr] (Maybe ())+          | CheckIsEmpty Type (Maybe ())+          | CheckWithFunctionType A.Expr (Maybe ())+          | CheckSectionApplication Range ModuleName A.ModuleApplication (Maybe ()) 	  | ScopeCheckExpr C.Expr (Maybe A.Expr) 	  | ScopeCheckDeclaration D.NiceDeclaration (Maybe [A.Declaration]) 	  | ScopeCheckLHS C.Name C.Pattern (Maybe A.LHS)-	  | ScopeCheckDefinition D.NiceDefinition (Maybe A.Definition) 	  | forall a. TermFunDef Range Name [A.Clause] (Maybe a) 	  | forall a. SetRange Range (Maybe a)	-- ^ used by 'setCurrentRange'             -- actually, 'a' is Agda.Termination.TermCheck.CallGraph@@ -633,38 +707,37 @@     getRange (CheckFunDef i _ _ _)                 = getRange i     getRange (CheckPragma r _ _)                   = r     getRange (CheckPrimitive i _ _ _)              = getRange i+    getRange CheckWithFunctionType{}               = noRange     getRange (ScopeCheckExpr e _)                  = getRange e     getRange (ScopeCheckDeclaration d _)           = getRange d     getRange (ScopeCheckLHS _ p _)                 = getRange p-    getRange (ScopeCheckDefinition d _)            = getRange d     getRange (CheckDotPattern e _ _)               = getRange e     getRange (CheckPatternShadowing c _)           = getRange c     getRange (TermFunDef i _ _ _)                  = getRange i     getRange (SetRange r _)                        = r-    getRange (CheckSectionApplication r _ _ _ _ _) = r+    getRange (CheckSectionApplication r _ _ _)     = r+    getRange (CheckIsEmpty _ _)                    = noRange  --------------------------------------------------------------------------- -- ** Builtin things --------------------------------------------------------------------------- +data BuiltinDescriptor = BuiltinData (TCM Type) [String]+                       | BuiltinDataCons (TCM Type)+                       | BuiltinPrim String (Term -> TCM ())+                       | BuiltinPostulate (TCM Type)+                       | BuiltinUnknown (Maybe (TCM Type)) (Term -> TCM ())++data BuiltinInfo =+   BuiltinInfo { builtinName :: String+               , builtinDesc :: BuiltinDescriptor }+ type BuiltinThings pf = Map String (Builtin pf)  data Builtin pf 	= Builtin Term 	| Prim pf-    deriving (Typeable, Data, Show)--instance Functor Builtin where-    fmap f (Builtin t) = Builtin t-    fmap f (Prim x)    = Prim $ f x--instance Foldable Builtin where-    foldr f z (Builtin t) = z-    foldr f z (Prim x)    = f x z--instance Traversable Builtin where-    traverse f (Builtin t) = pure $ Builtin t-    traverse f (Prim x)    = Prim <$> f x+    deriving (Typeable, Data, Show, Functor, Foldable, Traversable)  --------------------------------------------------------------------------- -- * Type checking environment@@ -677,23 +750,21 @@           , envAnonymousModules    :: [(ModuleName, Nat)] -- ^ anonymous modules and their number of free variables 	  , envImportPath          :: [C.TopLevelModuleName] -- ^ to detect import cycles 	  , envMutualBlock         :: Maybe MutualId -- ^ the current (if any) mutual block+          , envSolvingConstraints  :: Bool+                -- ^ Are we currently in the process of solving active constraints?+          , envActiveProblems      :: [ProblemId] 	  , envAbstractMode        :: AbstractMode 		-- ^ When checking the typesignature of a public definition 		--   or the body of a non-abstract definition this is true. 		--   To prevent information about abstract things leaking 		--   outside the module.-          , envIrrelevant          :: Bool-                -- ^ Are we checking an irrelevant argument?+          , envTopLevel            :: Bool+                -- ^ Are we at the top level when checking a declaration?+                --   In this case, we will freeze metas afterwards.+          , envRelevance           :: Relevance+                -- ^ Are we checking an irrelevant argument? (=@Irrelevant@)                 -- Then top-level irrelevant declarations are enabled.-          , envReplace             :: Bool-                -- ^ Coinductive constructor applications @c args@ get-                -- replaced by a function application @f tel@, where-                -- tel corresponds to the current telescope and @f@ is-                -- defined as @f tel = c args@. The initial occurrence-                -- of @c@ in the body of @f@ should not be replaced by-                -- yet another function application, though. To avoid-                -- that this happens the @envReplace@ flag is set to-                -- 'False' when @f@ is checked.+                -- Other value: @Relevant@, then only relevant decls. are avail.           , envDisplayFormsEnabled :: Bool                 -- ^ Sometimes we want to disable display forms.           , envReifyInteractionPoints :: Bool@@ -716,9 +787,11 @@                 , envAnonymousModules    = [] 		, envImportPath          = [] 		, envMutualBlock         = Nothing+                , envSolvingConstraints  = False+                , envActiveProblems      = [0] 		, envAbstractMode        = AbstractMode-                , envIrrelevant          = False-                , envReplace             = True+                , envTopLevel            = True+                , envRelevance           = Relevant                 , envDisplayFormsEnabled = True                 , envReifyInteractionPoints = True                 , envEtaContractImplicit    = True@@ -767,18 +840,40 @@                      , occClause   :: Int                      , occPosition :: OccPos                      }+  deriving (Show)  data OccPos = NonPositively | ArgumentTo Nat QName+  deriving (Show) +-- | Information about a call.++data CallInfo = CallInfo+  { callInfoRange :: Range+    -- ^ Range of the head identifier.+  , callInfoCall :: String+    -- ^ Formatted representation of the call.+    --+    -- ('Doc' would perhaps be better here, but 'Doc' doesn't come+    -- with an 'Ord' instance.)+  } deriving (Eq, Ord, Typeable, Show)++-- | Information about a mutual block which did not pass the+-- termination checker.++data TerminationError = TerminationError+  { termErrFunctions :: [QName]+    -- ^ The functions which failed to check. (May not include+    -- automatically generated functions.)+  , termErrCalls :: [CallInfo]+    -- ^ The problematic call sites.+  } deriving (Typeable, Show)+ data TypeError 	= InternalError String 	| NotImplemented String 	| NotSupported String         | CompilationError String-	| TerminationCheckFailed [([QName], [R.Range])]-          -- ^ Parameterised on functions which failed to termination-          --   check (grouped if they are mutual), along with ranges-          --   for problematic call sites.+	| TerminationCheckFailed [TerminationError] 	| PropMustBeSingleton 	| DataMustEndInSort Term 	| ShouldEndInApplicationOfTheDatatype Type@@ -804,6 +899,8 @@ 	    -- ^ Expected a non-hidden function and found a hidden lambda. 	| WrongHidingInApplication Type 	    -- ^ A function is applied to a hidden argument where a non-hidden was expected.+	| WrongIrrelevanceInLambda Type+	    -- ^ Expected a relevant function and found an irrelevant lambda. 	| NotInductive Term           -- ^ The term does not correspond to an inductive data type. 	| UninstantiatedDotPattern A.Expr@@ -829,6 +926,9 @@ 	| UnequalHiding Type Type 	    -- ^ The two function types have different hiding. 	| UnequalSorts Sort Sort+        | HeterogeneousEquality Term Type Term Type+            -- ^ We ended up with an equality constraint where the terms+            --   have different types.  This is not supported. 	| NotLeqSort Sort Sort 	| MetaCannotDependOn MetaId [Nat] Nat 	    -- ^ The arguments are the meta variable, the parameters it can@@ -856,7 +956,8 @@ 	| IncompletePatternMatching Term Args -- can only happen if coverage checking is switched off         | CoverageFailure QName [[Arg Pattern]]         | UnreachableClauses QName [[Arg Pattern]]-        | CoverageCantSplitOn QName+        | CoverageCantSplitOn QName Telescope Args Args+        | CoverageCantSplitIrrelevantType Type         | CoverageCantSplitType Type     -- Positivity errors 	| NotStrictlyPositive QName [Occ]@@ -896,16 +997,23 @@ 	| NotAnExpression C.Expr 	| NotAValidLetBinding D.NiceDeclaration 	| NothingAppliedToHiddenArg C.Expr+	| NothingAppliedToInstanceArg C.Expr     -- Operator errors 	| NoParseForApplication [C.Expr] 	| AmbiguousParseForApplication [C.Expr] [C.Expr] 	| NoParseForLHS C.Pattern 	| AmbiguousParseForLHS C.Pattern [C.Pattern]     -- Usage errors-          deriving (Typeable)+    -- Implicit From Scope errors+        | IFSNoCandidateInScope Type+    -- Safe flag errors+        | SafeFlagPostulate C.Name+        | SafeFlagPragma [String]+        | SafeFlagPrimTrustMe+          deriving (Typeable, Show) -instance Show TypeError where-  show _ = "<TypeError>" -- TODO: more info?+-- instance Show TypeError where+--   show _ = "<TypeError>" -- TODO: more info?  instance Error TypeError where     noMsg  = strMsg ""@@ -917,7 +1025,7 @@ 	    | Exception Range String             | IOException Range E.IOException 	    | PatternErr  TCState -- ^ for pattern violations-	    | AbortAssign TCState -- ^ used to abort assignment to meta when there are instantiations+	    {- AbortAssign TCState -- ^ used to abort assignment to meta when there are instantiations -- UNUSED -}   deriving (Typeable)  -- | Type-checking errors, potentially paired with relevant syntax@@ -943,14 +1051,14 @@     show (Exception r s) = show r ++ ": " ++ s     show (IOException r e) = show r ++ ": " ++ show e     show (PatternErr _)  = "Pattern violation (you shouldn't see this)"-    show (AbortAssign _) = "Abort assignment (you shouldn't see this)"+    {- show (AbortAssign _) = "Abort assignment (you shouldn't see this)" -- UNUSED -}  instance HasRange TCErr' where     getRange (TypeError _ cl)  = envRange $ clEnv cl     getRange (Exception r _)   = r     getRange (IOException r _) = r     getRange (PatternErr s)    = noRange-    getRange (AbortAssign s)   = noRange+    {- getRange (AbortAssign s)   = noRange -- UNUSED -}  instance HasRange TCErr where     getRange = getRange . errError@@ -961,15 +1069,15 @@ -- * Type checking monad transformer --------------------------------------------------------------------------- -newtype TCMT m a = TCM { unTCM :: TCState -> TCEnv -> m (a, TCState) }+newtype TCMT m a = TCM { unTCM :: IORef TCState -> TCEnv -> m a }  instance MonadIO m => MonadReader TCEnv (TCMT m) where-  ask = TCM $ \s e -> return (e, s)+  ask = TCM $ \s e -> return e   local f (TCM m) = TCM $ \s e -> m s (f e)  instance MonadIO m => MonadState TCState (TCMT m) where-  get   = TCM $ \s _ -> return (s, s)-  put s = TCM $ \_ _ -> return ((), s)+  get   = TCM $ \s _ -> liftIO (readIORef s)+  put s = TCM $ \r _ -> liftIO (writeIORef r s)  type TCM = TCMT IO @@ -981,20 +1089,32 @@  instance MonadError TCErr (TCMT IO) where   throwError = liftIO . throwIO-  catchError m h = TCM $ \s e ->-    unTCM m s e `E.catch` \err -> unTCM (h err) s e+  catchError m h = TCM $ \r e -> do+    oldState <- liftIO (readIORef r)+    unTCM m r e `E.catch` \err -> do+      -- Reset the state, but do not forget changes to the persistent+      -- component.+      liftIO $ do+        newState <- readIORef r+        writeIORef r $ oldState { stPersistent = stPersistent newState }+      unTCM (h err) r e +-- | Preserve the state of the failing computation. catchError_ :: TCM a -> (TCErr -> TCM a) -> TCM a-catchError_ m h = TCM $ \s e ->-  unTCM m s e-  `E.catch` \err -> unTCM (h err) (error "catchError_") e+catchError_ m h = TCM $ \r e ->+  unTCM m r e+  `E.catch` \err -> unTCM (h err) r e +{-# SPECIALIZE INLINE mapTCMT :: (forall a. IO a -> IO a) -> TCM a -> TCM a #-} mapTCMT :: (forall a. m a -> n a) -> TCMT m a -> TCMT n a mapTCMT f (TCM m) = TCM $ \s e -> f (m s e) -pureTCM :: Monad m => (TCState -> TCEnv -> a) -> TCMT m a-pureTCM f = TCM $ \s e -> return (f s e, s)+pureTCM :: MonadIO m => (TCState -> TCEnv -> a) -> TCMT m a+pureTCM f = TCM $ \r e -> do+  s <- liftIO $ readIORef r+  return (f s e) +{-# RULES "liftTCM/id" liftTCM = id #-} instance MonadIO m => MonadTCM (TCMT m) where     liftTCM = mapTCMT liftIO @@ -1002,15 +1122,16 @@   liftTCM = lift . liftTCM  instance MonadTrans TCMT where-    lift m = TCM $ \s _ -> m >>= \x -> return (x, s)+    lift m = TCM $ \_ _ -> m  -- We want a special monad implementation of fail. {-# SPECIALIZE instance Monad TCM #-} instance MonadIO m => Monad (TCMT m) where-    return x = TCM $ \s _ -> return (x, s)-    m >>= k = TCM $ \s e -> do-                (x, s') <- unTCM m s e-                unTCM (k x) s' e+    return x = TCM $ \_ _ -> return x+    TCM m >>= k = TCM $ \r e -> do+        x <- m r e+        let TCM m' = k x in m' r e+    TCM m1 >> TCM m2 = TCM $ \r e -> m1 r e >> m2 r e     fail    = internalError  instance MonadIO m => Functor (TCMT m) where@@ -1025,7 +1146,7 @@               do let r = envRange e                  liftIO $ wrap r $ do                  x <- m-                 x `seq` return (x, s)+                 x `seq` return x     where       wrap r m = failOnException handleException                $ E.catch m (handleIOException r)@@ -1033,8 +1154,8 @@       handleIOException r e = throwIO $ TCErr Nothing $ IOException r e       handleException   r s = throwIO $ TCErr Nothing $ Exception r s -patternViolation :: MonadTCM tcm => tcm a-patternViolation = liftTCM $ do+patternViolation :: TCM a+patternViolation = do     s <- get     throwError $ TCErr Nothing $ PatternErr s @@ -1051,5 +1172,13 @@ runTCM :: TCMT IO a -> IO (Either TCErr a) runTCM m = (Right <$> runTCM' m) `E.catch` (return . Left) -runTCM' :: Monad m => TCMT m a -> m a-runTCM' m = liftM fst (unTCM m initState initEnv)+runTCM' :: MonadIO m => TCMT m a -> m a+runTCM' m = do+  r <- liftIO $ newIORef initState+  unTCM m r initEnv+++++-- | Base name for extended lambda patterns+extendlambdaname = ".extendedlambda"

src/full/Agda/TypeChecking/Monad/Builtin.hs view

@@ -1,6 +1,7 @@  module Agda.TypeChecking.Monad.Builtin where +import Data.Functor import Control.Monad.State import qualified Data.Map as Map @@ -8,16 +9,17 @@ import Agda.Syntax.Internal import Agda.TypeChecking.Monad.Base -getBuiltinThings :: MonadTCM tcm => tcm (BuiltinThings PrimFun)-getBuiltinThings = gets stBuiltinThings+getBuiltinThing :: String -> TCM (Maybe (Builtin PrimFun))+getBuiltinThing b = liftM2 mplus (Map.lookup b <$> gets stLocalBuiltins)+                    (Map.lookup b <$> gets stImportedBuiltins) -setBuiltinThings :: MonadTCM tcm => BuiltinThings PrimFun -> tcm ()+setBuiltinThings :: BuiltinThings PrimFun -> TCM () setBuiltinThings b = modify $ \s -> s { stLocalBuiltins = b } -bindBuiltinName :: MonadTCM tcm => String -> Term -> tcm ()+bindBuiltinName :: String -> Term -> TCM () bindBuiltinName b x = do-	builtin <- getBuiltinThings-	case Map.lookup b builtin of+	builtin <- getBuiltinThing b+	case builtin of 	    Just (Builtin y) -> typeError $ DuplicateBuiltinBinding b y x 	    Just (Prim _)    -> typeError $ NoSuchBuiltinName b 	    Nothing	     -> modify $ \st ->@@ -25,30 +27,30 @@                     Map.insert b (Builtin x) $ stLocalBuiltins st                  } -bindPrimitive :: MonadTCM tcm => String -> PrimFun -> tcm ()+bindPrimitive :: String -> PrimFun -> TCM () bindPrimitive b pf = do   builtin <- gets stLocalBuiltins   setBuiltinThings $ Map.insert b (Prim pf) builtin  -getBuiltin :: MonadTCM tcm => String -> tcm Term+getBuiltin :: String -> TCM Term getBuiltin x = do     mt <- getBuiltin' x     case mt of         Nothing -> typeError $ NoBindingForBuiltin x         Just t  -> return t -getBuiltin' :: MonadTCM tcm => String -> tcm (Maybe Term)+getBuiltin' :: String -> TCM (Maybe Term) getBuiltin' x = do-    builtin <- getBuiltinThings-    case Map.lookup x builtin of+    builtin <- getBuiltinThing x+    case builtin of 	Just (Builtin t) -> return $ Just (killRange t) 	_		 -> return Nothing -getPrimitive :: MonadTCM tcm => String -> tcm PrimFun+getPrimitive :: String -> TCM PrimFun getPrimitive x = do-    builtin <- getBuiltinThings-    case Map.lookup x builtin of+    builtin <- getBuiltinThing x+    case builtin of 	Just (Prim pf) -> return pf 	_	       -> typeError $ NoSuchPrimitiveFunction x @@ -66,8 +68,15 @@     -- builtins for reflection:     primQName, primArg, primArgArg, primAgdaTerm, primAgdaTermVar,     primAgdaTermLam, primAgdaTermDef, primAgdaTermCon, primAgdaTermPi,-    primAgdaTermSort, primAgdaTermUnsupported-    :: MonadTCM tcm => tcm Term+    primAgdaTermSort, primAgdaTermUnsupported,+    primAgdaType, primAgdaTypeEl,+    primHiding, primHidden, primInstance, primVisible,+    primRelvance, primRelevant, primIrrelevant,+    primAgdaSort, primAgdaSortSet, primAgdaSortLit, primAgdaSortUnsupported,+    primAgdaDefinition, primAgdaDefinitionFunDef, primAgdaDefinitionDataDef, primAgdaDefinitionRecordDef,+    primAgdaDefinitionPostulate, primAgdaDefinitionPrimitive, primAgdaDefinitionDataConstructor,+    primAgdaFunDef, primAgdaDataDef, primAgdaRecordDef+    :: TCM Term primInteger      = getBuiltin builtinInteger primFloat        = getBuiltin builtinFloat primChar         = getBuiltin builtinChar@@ -104,6 +113,19 @@ primQName        = getBuiltin builtinQName primArg          = getBuiltin builtinArg primArgArg       = getBuiltin builtinArgArg+primAgdaSort     = getBuiltin builtinAgdaSort+primAgdaType     = getBuiltin builtinAgdaType+primAgdaTypeEl   = getBuiltin builtinAgdaTypeEl+primHiding       = getBuiltin builtinHiding+primHidden       = getBuiltin builtinHidden+primInstance     = getBuiltin builtinInstance+primVisible      = getBuiltin builtinVisible+primRelvance     = getBuiltin builtinRelevance+primRelevant     = getBuiltin builtinRelevant+primIrrelevant   = getBuiltin builtinIrrelevant+primAgdaSortSet  = getBuiltin builtinAgdaSortSet+primAgdaSortLit  = getBuiltin builtinAgdaSortLit+primAgdaSortUnsupported = getBuiltin builtinAgdaSortUnsupported primAgdaTerm         = getBuiltin builtinAgdaTerm primAgdaTermVar      = getBuiltin builtinAgdaTermVar primAgdaTermLam      = getBuiltin builtinAgdaTermLam@@ -112,7 +134,16 @@ primAgdaTermPi       = getBuiltin builtinAgdaTermPi primAgdaTermSort     = getBuiltin builtinAgdaTermSort primAgdaTermUnsupported     = getBuiltin builtinAgdaTermUnsupported-+primAgdaFunDef                    = getBuiltin builtinAgdaFunDef+primAgdaDataDef                   = getBuiltin builtinAgdaDataDef+primAgdaRecordDef                 = getBuiltin builtinAgdaRecordDef+primAgdaDefinitionFunDef          = getBuiltin builtinAgdaDefinitionFunDef+primAgdaDefinitionDataDef         = getBuiltin builtinAgdaDefinitionDataDef+primAgdaDefinitionRecordDef       = getBuiltin builtinAgdaDefinitionRecordDef+primAgdaDefinitionDataConstructor = getBuiltin builtinAgdaDefinitionDataConstructor+primAgdaDefinitionPostulate       = getBuiltin builtinAgdaDefinitionPostulate+primAgdaDefinitionPrimitive       = getBuiltin builtinAgdaDefinitionPrimitive+primAgdaDefinition                = getBuiltin builtinAgdaDefinition builtinNat          = "NATURAL" builtinSuc          = "SUC" builtinZero         = "ZERO"@@ -147,6 +178,19 @@ builtinLevelZero    = "LEVELZERO" builtinLevelSuc     = "LEVELSUC" builtinQName        = "QNAME"+builtinAgdaSort     = "AGDASORT"+builtinAgdaSortSet  = "AGDASORTSET"+builtinAgdaSortLit  = "AGDASORTLIT"+builtinAgdaSortUnsupported = "AGDASORTUNSUPPORTED"+builtinAgdaType     = "AGDATYPE"+builtinAgdaTypeEl   = "AGDATYPEEL"+builtinHiding       = "HIDING"+builtinHidden       = "HIDDEN"+builtinInstance     = "INSTANCE"+builtinVisible      = "VISIBLE"+builtinRelevance    = "RELEVANCE"+builtinRelevant     = "RELEVANT"+builtinIrrelevant   = "IRRELEVANT" builtinArg          = "ARG" builtinArgArg       = "ARGARG" builtinAgdaTerm         = "AGDATERM"@@ -157,16 +201,13 @@ builtinAgdaTermPi       = "AGDATERMPI" builtinAgdaTermSort     = "AGDATERMSORT" builtinAgdaTermUnsupported = "AGDATERMUNSUPPORTED"--builtinTypes :: [String]-builtinTypes =-    [ builtinInteger-    , builtinFloat-    , builtinChar-    , builtinString-    , builtinBool-    , builtinNat-    , builtinLevel-    , builtinQName-    , builtinAgdaTerm-    ]+builtinAgdaFunDef                    = "AGDAFUNDEF"+builtinAgdaDataDef                   = "AGDADATADEF"+builtinAgdaRecordDef                 = "AGDARECORDDEF"+builtinAgdaDefinitionFunDef          = "AGDADEFINITIONFUNDEF"+builtinAgdaDefinitionDataDef         = "AGDADEFINITIONDATADEF"+builtinAgdaDefinitionRecordDef       = "AGDADEFINITIONRECORDDEF"+builtinAgdaDefinitionDataConstructor = "AGDADEFINITIONDATACONSTRUCTOR"+builtinAgdaDefinitionPostulate       = "AGDADEFINITIONPOSTULATE"+builtinAgdaDefinitionPrimitive       = "AGDADEFINITIONPRIMITIVE"+builtinAgdaDefinition                = "AGDADEFINITION"

src/full/Agda/TypeChecking/Monad/Closure.hs view

@@ -7,7 +7,7 @@ import Agda.TypeChecking.Monad.Signature import Agda.TypeChecking.Monad.Trace -enterClosure :: MonadTCM tcm => Closure a -> (a -> tcm b) -> tcm b+enterClosure :: Closure a -> (a -> TCM b) -> TCM b enterClosure (Closure sig env scope x) k =     withScope_ scope     $ withEnv env

src/full/Agda/TypeChecking/Monad/Constraints.hs view

@@ -1,41 +1,131 @@-+{-# LANGUAGE CPP #-} module Agda.TypeChecking.Monad.Constraints where +import Control.Arrow ((&&&))+import Control.Applicative import Control.Monad.State+import Control.Monad.Reader import Data.Map as Map+import Data.List as List  import Agda.TypeChecking.Monad.Base import Agda.TypeChecking.Monad.Signature import Agda.TypeChecking.Monad.Env import Agda.TypeChecking.Monad.State import Agda.TypeChecking.Monad.Closure+import Agda.TypeChecking.Monad.Options+import Agda.Utils.Monad+import Agda.Utils.Impossible --- | Get the constraints-getConstraints :: MonadTCM tcm => tcm Constraints-getConstraints = gets stConstraints+#include "../../undefined.h" -lookupConstraint :: MonadTCM tcm => Int -> tcm ConstraintClosure-lookupConstraint i =-    do	cs <- getConstraints-	unless (i < length cs) $ fail $ "no such constraint: " ++ show i-	return $ cs !! i+-- | Get the current problem+currentProblem :: TCM ProblemId+currentProblem = asks $ head' . envActiveProblems+  where+    head' []    = {- ' -} __IMPOSSIBLE__+    head' (x:_) = x --- | Take constraints (clear all constraints).-takeConstraints :: MonadTCM tcm => tcm Constraints-takeConstraints =-    do	cs <- getConstraints-	modify $ \s -> s { stConstraints = [] }-	return cs+-- | Steal all constraints belonging to the given problem and add them to the current problem.+stealConstraints :: ProblemId -> TCM ()+stealConstraints pid = do+  current <- currentProblem+  reportSLn "tc.constr.steal" 50 $ "problem " ++ show current ++ " is stealing problem " ++ show pid ++ "'s constraints!"+  let rename pc@(PConstr pid' c) | pid' == pid = PConstr current c+                                 | otherwise   = pc+  -- We should never steal from an active problem.+  whenM (elem pid <$> asks envActiveProblems) __IMPOSSIBLE__+  modify $ \s -> s { stAwakeConstraints    = List.map rename $ stAwakeConstraints s+                   , stSleepingConstraints = List.map rename $ stSleepingConstraints s } -withConstraint :: MonadTCM tcm => (Constraint -> tcm a) -> ConstraintClosure -> tcm a-withConstraint = flip enterClosure+solvingProblem :: ProblemId -> TCM a -> TCM a+solvingProblem pid m = verboseBracket "tc.constr.solve" 50 ("working on problem " ++ show pid) $ do+  x <- local (\e -> e { envActiveProblems = pid : envActiveProblems e }) m+  ifM (isProblemSolved pid) (do+      reportSLn "tc.constr.solve" 50 $ "problem " ++ show pid ++ " was solved!"+      wakeConstraints (blockedOn pid . clValue . theConstraint)+    ) (reportSLn "tc.constr.solve" 50 $ "problem " ++ show pid ++ " was not solved.")+  return x+  where+    blockedOn pid (Guarded _ pid') = pid == pid'+    blockedOn _ _ = False --- | Add new constraints-addConstraints :: MonadTCM tcm => Constraints -> tcm ()-addConstraints cs = modify $ \st -> st { stConstraints = cs ++ stConstraints st }+isProblemSolved :: ProblemId -> TCM Bool+isProblemSolved pid =+  (&&) <$> (notElem pid <$> asks envActiveProblems)+       <*> (all ((/= pid) . constraintProblem) <$> getAllConstraints) --- | Create a new constraint.-buildConstraint :: MonadTCM tcm => Constraint -> tcm Constraints-buildConstraint c = do-    cl <- buildClosure c-    return [cl]+getConstraintsForProblem :: ProblemId -> TCM Constraints+getConstraintsForProblem pid = List.filter ((== pid) . constraintProblem) <$> getAllConstraints++-- | Get the awake constraints+getAwakeConstraints :: TCM Constraints+getAwakeConstraints = gets stAwakeConstraints++wakeConstraints :: (ProblemConstraint-> Bool) -> TCM ()+wakeConstraints wake = do+  sleepers <- gets stSleepingConstraints+  let (wakeup, sleepin) = List.partition wake sleepers+  reportSLn "tc.constr.wake" 50 $ "waking up         " ++ show (List.map constraintProblem wakeup) ++ "\n" +++                                  "  still sleeping: " ++ show (List.map constraintProblem sleepin)+  modify $ \s ->+    s { stSleepingConstraints = sleepin+      , stAwakeConstraints    = stAwakeConstraints s ++ wakeup+      }++takeAwakeConstraint :: TCM (Maybe ProblemConstraint)+takeAwakeConstraint = do+  cs <- getAwakeConstraints+  case cs of+    []     -> return Nothing+    c : cs -> do+      modify $ \s -> s { stAwakeConstraints = cs }+      return (Just c)++getAllConstraints :: TCM Constraints+getAllConstraints = gets $ \s -> stAwakeConstraints s ++ stSleepingConstraints s++withConstraint :: (Constraint -> TCM a) -> ProblemConstraint -> TCM a+withConstraint f (PConstr pid c) = do+  -- We should preserve the problem stack and the isSolvingConstraint flag+  (pids, isSolving) <- asks $ envActiveProblems &&& envSolvingConstraints+  enterClosure c $ \c ->+    local (\e -> e { envActiveProblems = pids, envSolvingConstraints = isSolving }) $+    solvingProblem pid (f c)++buildProblemConstraint :: ProblemId -> Constraint -> TCM ProblemConstraint+buildProblemConstraint pid c = PConstr pid <$> buildClosure c++buildConstraint :: Constraint -> TCM ProblemConstraint+buildConstraint c = flip buildProblemConstraint c =<< currentProblem++-- | Add new a constraint+addConstraint' :: Constraint -> TCM ()+addConstraint' c = do+    pc <- build+    modify $ \s -> s { stSleepingConstraints = pc : stSleepingConstraints s }+  where+    build | isBlocking c = buildConstraint c+          | otherwise    = buildProblemConstraint 0 c+    isBlocking SortCmp{}     = False+    isBlocking LevelCmp{}    = False+    isBlocking ValueCmp{}    = True+    isBlocking ElimCmp{}     = True+    isBlocking TypeCmp{}     = True+    isBlocking TelCmp{}      = True+    isBlocking (Guarded c _) = isBlocking c+    isBlocking UnBlock{}     = True+    isBlocking FindInScope{} = False+    isBlocking IsEmpty{}     = True++-- | Add already awake constraints+addAwakeConstraints :: Constraints -> TCM ()+addAwakeConstraints cs = modify $ \s -> s { stAwakeConstraints = cs ++ stAwakeConstraints s }++-- | Start solving constraints+nowSolvingConstraints :: TCM a -> TCM a+nowSolvingConstraints = local $ \e -> e { envSolvingConstraints = True }++isSolvingConstraints :: TCM Bool+isSolvingConstraints = asks envSolvingConstraints+

src/full/Agda/TypeChecking/Monad/Context.hs view

@@ -21,13 +21,29 @@ #include "../../undefined.h" import Agda.Utils.Impossible +-- | Modify the 'ctxEntry' field of a 'ContextEntry'.+modifyContextEntry :: (Arg (Name, Type) -> Arg (Name, Type)) -> ContextEntry -> ContextEntry+modifyContextEntry f ce = ce { ctxEntry = f (ctxEntry ce) }++-- | Modify all 'ContextEntry's.+modifyContextEntries :: (Arg (Name, Type) -> Arg (Name, Type)) -> Context -> Context+modifyContextEntries f = map (modifyContextEntry f)++-- | Modify a 'Context' in a computation.+{-# SPECIALIZE modifyContext :: (Context -> Context) -> TCM a -> TCM a #-}+modifyContext :: MonadTCM tcm => (Context -> Context) -> tcm a -> tcm a+modifyContext f = local $ \ e -> e { envContext = f (envContext e) }++{-# SPECIALIZE mkContextEntry :: Arg (Name, Type) -> TCM ContextEntry #-} mkContextEntry :: MonadTCM tcm => Arg (Name, Type) -> tcm ContextEntry mkContextEntry x = do   i <- fresh   return $ Ctx i x --- | add a variable to the context+-- | @addCtx x arg cont@ add a variable to the context. --+--   Chooses an unused 'Name'.+{-# SPECIALIZE addCtx :: Name -> Arg Type -> TCM a -> TCM a #-} addCtx :: MonadTCM tcm => Name -> Arg Type -> tcm a -> tcm a addCtx x a ret = do   ctx <- map (nameConcrete . fst . unArg) <$> getContext@@ -38,93 +54,107 @@   where     notTaken xs x = isNoName (nameConcrete x) || nameConcrete x `notElem` xs +-- | N-ary variant of @addCtx@.+{-# SPECIALIZE addContext :: [Arg (Name, Type)] -> TCM a -> TCM a #-}+addContext :: MonadTCM tcm => [Arg (Name, Type)] -> tcm a -> tcm a+addContext ctx m =+  foldr (\arg -> addCtx (fst $ unArg arg) (fmap snd arg)) m ctx++-- | Turns the string into a name and adds it to the context.+{-# SPECIALIZE addCtxString :: String -> Arg Type -> TCM a -> TCM a #-}+addCtxString :: MonadTCM tcm => String -> Arg Type -> tcm a -> tcm a+addCtxString s a m = do+  x <- freshName_ s+  addCtx x a m+ -- | Change the context+{-# SPECIALIZE inContext :: [Arg (Name, Type)] -> TCM a -> TCM a #-} inContext :: MonadTCM tcm => [Arg (Name, Type)] -> tcm a -> tcm a inContext xs ret = do   ctx <- mapM mkContextEntry xs   flip local ret $ \e -> e { envContext = ctx }  -- | Go under an abstraction.-underAbstraction :: MonadTCM tcm => Arg Type -> Abs a -> (a -> tcm b) -> tcm b+{-# SPECIALIZE underAbstraction :: Raise a => Arg Type -> Abs a -> (a -> TCM b) -> TCM b #-}+underAbstraction :: (Raise a, MonadTCM tcm) => Arg Type -> Abs a -> (a -> tcm b) -> tcm b+underAbstraction _ (NoAbs _ v) k = k v underAbstraction t a k = do     xs <- map (nameConcrete . fst . unArg) <$> getContext     x <- freshName_ $ realName $ absName a     let y = head $ filter (notTaken xs) $ iterate nextName x     addCtx y t $ k $ absBody a   where-    notTaken xs x = notElem (nameConcrete x) xs+    notTaken xs x = isNoName (nameConcrete x) || notElem (nameConcrete x) xs     realName "_" = "y"     realName s   = s  -- | Go under an abstract without worrying about the type to add to the context.-underAbstraction_ :: MonadTCM tcm => Abs a -> (a -> tcm b) -> tcm b+{-# SPECIALIZE underAbstraction_ :: Raise a => Abs a -> (a -> TCM b) -> TCM b #-}+underAbstraction_ :: (Raise a, MonadTCM tcm) => Abs a -> (a -> tcm b) -> tcm b underAbstraction_ = underAbstraction (Arg NotHidden Relevant $ sort Prop)  -- | Add a telescope to the context.+{-# SPECIALIZE addCtxTel :: Telescope -> TCM a -> TCM a #-} addCtxTel :: MonadTCM tcm => Telescope -> tcm a -> tcm a addCtxTel EmptyTel	    ret = ret addCtxTel (ExtendTel t tel) ret = underAbstraction t tel $ \tel -> addCtxTel tel ret  -- | Get the current context.+{-# SPECIALIZE getContext :: TCM [Arg (Name, Type)] #-} getContext :: MonadTCM tcm => tcm [Arg (Name, Type)] getContext = asks $ map ctxEntry . envContext  -- | Generate [Var n - 1, .., Var 0] for all declarations in the context.+{-# SPECIALIZE getContextArgs :: TCM Args #-} getContextArgs :: MonadTCM tcm => tcm Args getContextArgs = do   ctx <- getContext   return $ reverse $ [ Arg h r $ Var i [] | (Arg h r _, i) <- zip ctx [0..] ] +{-# SPECIALIZE getContextTerms :: TCM [Term] #-} getContextTerms :: MonadTCM tcm => tcm [Term] getContextTerms = map unArg <$> getContextArgs  -- | Get the current context as a 'Telescope' with the specified 'Hiding'.+{-# SPECIALIZE getContextTelescope :: TCM Telescope #-} getContextTelescope :: MonadTCM tcm => tcm Telescope getContextTelescope = foldr extTel EmptyTel . reverse <$> getContext   where     extTel (Arg h r (x, t)) = ExtendTel (Arg h r t) . Abs (show x)  -- | add a bunch of variables with the same type to the context+{-# SPECIALIZE addCtxs :: [Name] -> Arg Type -> TCM a -> TCM a #-} addCtxs :: MonadTCM tcm => [Name] -> Arg Type -> tcm a -> tcm a addCtxs []     _ k = k addCtxs (x:xs) t k = addCtx x t $ addCtxs xs (raise 1 t) k  -- | Check if we are in a compatible context, i.e. an extension of the given context.+{-# SPECIALIZE getContextId :: TCM [CtxId] #-} getContextId :: MonadTCM tcm => tcm [CtxId] getContextId = asks $ map ctxId . envContext  -- | Add a let bound variable+{-# SPECIALIZE addLetBinding :: Relevance -> Name -> Term -> Type -> TCM a -> TCM a #-} addLetBinding :: MonadTCM tcm => Relevance -> Name -> Term -> Type -> tcm a -> tcm a addLetBinding rel x v t0 ret = do     let t = Arg NotHidden rel t0-    vt <- makeOpen (v, t)+    vt <- liftTCM $ makeOpen (v, t)     flip local ret $ \e -> e { envLetBindings = Map.insert x vt $ envLetBindings e } --- | Wake up irrelevant variables and make them relevant.  For instance,---   in an irrelevant function argument otherwise irrelevant variables---   may be used, so they are awoken before type checking the argument.-wakeIrrelevantVars :: MonadTCM tcm => tcm a -> tcm a-wakeIrrelevantVars = local $ \ e -> e-   { envContext = map wakeVar (envContext e) -- enable local  irr. defs-   , envIrrelevant = True                    -- enable global irr. defs-   }-  where wakeVar ce = ce { ctxEntry = makeRelevant (ctxEntry ce) }--applyRelevanceToContext :: MonadTCM tcm => Relevance -> tcm a -> tcm a-applyRelevanceToContext Irrelevant cont = wakeIrrelevantVars cont-applyRelevanceToContext _          cont = cont- -- | get type of bound variable (i.e. deBruijn index) --+{-# SPECIALIZE typeOfBV' :: Nat -> TCM (Arg Type) #-} typeOfBV' :: MonadTCM tcm => Nat -> tcm (Arg Type) typeOfBV' n =     do	ctx <- getContext 	Arg h r (_,t) <- ctx !!! n 	return $ Arg h r $ raise (n + 1) t +{-# SPECIALIZE typeOfBV :: Nat -> TCM Type #-} typeOfBV :: MonadTCM tcm => Nat -> tcm Type typeOfBV i = unArg <$> typeOfBV' i +{-# SPECIALIZE nameOfBV :: Nat -> TCM Name #-} nameOfBV :: MonadTCM tcm => Nat -> tcm Name nameOfBV n =     do	ctx <- getContext@@ -143,6 +173,7 @@ -- | Get the term corresponding to a named variable. If it is a lambda bound --   variable the deBruijn index is returned and if it is a let bound variable --   its definition is returned.+{-# SPECIALIZE getVarInfo :: Name -> TCM (Term, Arg Type) #-} getVarInfo :: MonadTCM tcm => Name -> tcm (Term, Arg Type) getVarInfo x =     do	ctx <- getContext@@ -154,8 +185,9 @@ 		    return (Var n [], t) 	    _	    -> 		case Map.lookup x def of-		    Just vt -> getOpen vt+		    Just vt -> liftTCM $ getOpen vt 		    _	    -> fail $ "unbound variable " ++ show x +{-# SPECIALIZE escapeContext :: Int -> TCM a -> TCM a #-} escapeContext :: MonadTCM tcm => Int -> tcm a -> tcm a escapeContext n = local $ \e -> e { envContext = drop n $ envContext e }

src/full/Agda/TypeChecking/Monad/Context.hs-boot view

@@ -7,4 +7,3 @@  getContext   :: MonadTCM tcm => tcm [Arg (Name, Type)] getContextId :: MonadTCM tcm => tcm [CtxId]-

src/full/Agda/TypeChecking/Monad/Env.hs view

@@ -10,30 +10,37 @@ import Agda.TypeChecking.Monad.Base  -- | Get the name of the current module, if any.-currentModule :: MonadTCM tcm => tcm ModuleName+currentModule :: TCM ModuleName currentModule = asks envCurrentModule  -- | Set the name of the current module.-withCurrentModule :: MonadTCM tcm => ModuleName -> tcm a -> tcm a+withCurrentModule :: ModuleName -> TCM a -> TCM a withCurrentModule m =     local $ \e -> e { envCurrentModule = m }  -- | Get the number of variables bound by anonymous modules.-getAnonymousVariables :: MonadTCM tcm => ModuleName -> tcm Nat+getAnonymousVariables :: ModuleName -> TCM Nat getAnonymousVariables m = do   ms <- asks envAnonymousModules   return $ sum [ n | (m', n) <- ms, mnameToList m' `isPrefixOf` mnameToList m ]  -- | Add variables bound by an anonymous module.-withAnonymousModule :: MonadTCM tcm => ModuleName -> Nat -> tcm a -> tcm a+withAnonymousModule :: ModuleName -> Nat -> TCM a -> TCM a withAnonymousModule m n =   local $ \e -> e { envAnonymousModules   = (m, n) : envAnonymousModules e                   }  -- | Set the current environment to the given-withEnv :: MonadTCM tcm => TCEnv -> tcm a -> tcm a+withEnv :: TCEnv -> TCM a -> TCM a withEnv env m = local (const env) m  -- | Get the current environmnet-getEnv :: MonadTCM tcm => tcm TCEnv+getEnv :: TCM TCEnv getEnv = ask++-- | Leave the top level to type check local things.+leaveTopLevel :: TCM a -> TCM a+leaveTopLevel = local $ \ env -> env { envTopLevel = False }++onTopLevel :: TCM Bool+onTopLevel = asks envTopLevel

src/full/Agda/TypeChecking/Monad/Exception.hs view

@@ -2,6 +2,7 @@  -- | Basically a copy of the ErrorT monad transformer. It's handy to slap --   onto TCM and still be a MonadTCM (which isn't possible with ErrorT).+--   Also, it does not require the silly Error instance for the err type.  module Agda.TypeChecking.Monad.Exception where @@ -9,6 +10,7 @@ import Control.Monad.Error import Control.Monad.State import Control.Monad.Reader+import Control.Monad.Writer import Agda.TypeChecking.Monad.Base  newtype ExceptionT err m a = ExceptionT { runExceptionT :: m (Either err a) }@@ -33,6 +35,16 @@     case r of       Left err  -> runExceptionT $ h err       Right x   -> return $ Right x++instance (Monad m, MonadException err m) => MonadException err (ReaderT r m) where+  throwException = lift . throwException+  catchException m h = ReaderT $ \ r ->+    catchException (m `runReaderT` r) (\ err -> h err `runReaderT` r)++instance (Monad m, MonadException err m, Monoid w) => MonadException err (WriterT w m) where+  throwException = lift . throwException+  catchException m h = WriterT $+    catchException (runWriterT m) (\ err -> runWriterT $ h err)  instance MonadTrans (ExceptionT err) where   lift = ExceptionT . liftM Right

src/full/Agda/TypeChecking/Monad/Imports.hs view

@@ -56,28 +56,30 @@ getVisitedModule x = gets $ Map.lookup x . stVisitedModules  getDecodedModules :: TCM DecodedModules-getDecodedModules = gets stDecodedModules+getDecodedModules = stDecodedModules . stPersistent <$> get  setDecodedModules :: DecodedModules -> TCM ()-setDecodedModules ms = modify $ \s -> s { stDecodedModules = ms }--preserveDecodedModules :: TCM a -> TCM a-preserveDecodedModules tcm = do ms <- getDecodedModules-                                a  <- tcm-                                setDecodedModules ms-                                return a+setDecodedModules ms = modify $ \s ->+  s { stPersistent = (stPersistent s) { stDecodedModules = ms } }  getDecodedModule :: C.TopLevelModuleName -> TCM (Maybe (Interface, ClockTime))-getDecodedModule x = gets $ Map.lookup x . stDecodedModules+getDecodedModule x = Map.lookup x . stDecodedModules . stPersistent <$> get  storeDecodedModule :: Interface -> ClockTime -> TCM () storeDecodedModule i t = modify $ \s ->-  s { stDecodedModules =-        Map.insert (toTopLevelModuleName $ iModuleName i) (i, t) $-          stDecodedModules s }+  s { stPersistent =+        (stPersistent s) { stDecodedModules =+          Map.insert (toTopLevelModuleName $ iModuleName i) (i, t) $+            (stDecodedModules $ stPersistent s)+        }+  }  dropDecodedModule :: C.TopLevelModuleName -> TCM ()-dropDecodedModule x = modify $ \s -> s { stDecodedModules = Map.delete x $ stDecodedModules s }+dropDecodedModule x = modify $ \s ->+  s { stPersistent = (stPersistent s) { stDecodedModules =+                       Map.delete x $ stDecodedModules $ stPersistent s+                     }+  }  withImportPath :: [C.TopLevelModuleName] -> TCM a -> TCM a withImportPath path = local $ \e -> e { envImportPath = path }

src/full/Agda/TypeChecking/Monad/MetaVars.hs view

@@ -19,6 +19,7 @@ import Agda.TypeChecking.Monad.Closure import Agda.TypeChecking.Monad.Open import Agda.TypeChecking.Substitute+-- import Agda.TypeChecking.Pretty -- LEADS TO import cycle  import Agda.Utils.Monad import Agda.Utils.Fresh@@ -28,32 +29,35 @@ import Agda.Utils.Impossible  -- | Get the meta store.-getMetaStore :: MonadTCM tcm => tcm MetaStore+getMetaStore :: TCM MetaStore getMetaStore = gets stMetaStore +modifyMetaStore :: (MetaStore -> MetaStore) -> TCM ()+modifyMetaStore f = modify (\ st -> st { stMetaStore = f $ stMetaStore st })+ -- | Lookup a meta variable-lookupMeta :: MonadTCM tcm => MetaId -> tcm MetaVariable+lookupMeta :: MetaId -> TCM MetaVariable lookupMeta m =     do	mmv <- Map.lookup m <$> getMetaStore 	case mmv of 	    Just mv -> return mv 	    _	    -> fail $ "no such meta variable " ++ show m -updateMetaVar :: MonadTCM tcm => MetaId -> (MetaVariable -> MetaVariable) -> tcm ()+updateMetaVar :: MetaId -> (MetaVariable -> MetaVariable) -> TCM () updateMetaVar m f =   modify $ \st -> st { stMetaStore = Map.adjust f m $ stMetaStore st } -getMetaPriority :: MonadTCM tcm => MetaId -> tcm MetaPriority+getMetaPriority :: MetaId -> TCM MetaPriority getMetaPriority i = mvPriority <$> lookupMeta i -isSortMeta :: MonadTCM tcm => MetaId -> tcm Bool+isSortMeta :: MetaId -> TCM Bool isSortMeta m = do   mv <- lookupMeta m   return $ case mvJudgement mv of     HasType{} -> False     IsSort{}  -> True -isInstantiatedMeta :: MonadTCM tcm => MetaId -> tcm Bool+isInstantiatedMeta :: MetaId -> TCM Bool isInstantiatedMeta m = do   mv <- lookupMeta m   return $ case mvInstantiation mv of@@ -61,98 +65,105 @@     InstS{} -> True     _       -> False -createMetaInfo :: MonadTCM tcm => tcm MetaInfo+createMetaInfo :: TCM MetaInfo createMetaInfo =     do  r <- getCurrentRange 	buildClosure r -updateMetaVarRange :: MonadTCM tcm => MetaId -> Range -> tcm ()+updateMetaVarRange :: MetaId -> Range -> TCM () updateMetaVarRange mi r = updateMetaVar mi (setRange r) -addInteractionPoint :: MonadTCM tcm => InteractionId -> MetaId -> tcm ()+addInteractionPoint :: InteractionId -> MetaId -> TCM () addInteractionPoint ii mi =     modify $ \s -> s { stInteractionPoints = 			Map.insert ii mi $ stInteractionPoints s 		     }  -removeInteractionPoint :: MonadTCM tcm => InteractionId -> tcm ()+removeInteractionPoint :: InteractionId -> TCM () removeInteractionPoint ii =     modify $ \s -> s { stInteractionPoints = 			Map.delete ii $ stInteractionPoints s 		     }  -getInteractionPoints :: MonadTCM tcm => tcm [InteractionId]+getInteractionPoints :: TCM [InteractionId] getInteractionPoints = Map.keys <$> gets stInteractionPoints -getInteractionMetas :: MonadTCM tcm => tcm [MetaId]+getInteractionMetas :: TCM [MetaId] getInteractionMetas = Map.elems <$> gets stInteractionPoints  -- | Does the meta variable correspond to an interaction point? -isInteractionMeta :: MonadTCM tcm => MetaId -> tcm Bool+isInteractionMeta :: MetaId -> TCM Bool isInteractionMeta m = fmap (m `elem`) getInteractionMetas -lookupInteractionId :: MonadTCM tcm => InteractionId -> tcm MetaId+lookupInteractionId :: InteractionId -> TCM MetaId lookupInteractionId ii =     do  mmi <- Map.lookup ii <$> gets stInteractionPoints 	case mmi of 	    Just mi -> return mi 	    _	    -> fail $ "no such interaction point: " ++ show ii -judgementInteractionId :: MonadTCM tcm => InteractionId -> tcm (Judgement Type MetaId)+judgementInteractionId :: InteractionId -> TCM (Judgement Type MetaId) judgementInteractionId ii =     do  mi <- lookupInteractionId ii         mvJudgement <$> lookupMeta mi  -- | Generate new meta variable.-newMeta :: MonadTCM tcm => MetaInfo -> MetaPriority -> Permutation -> Judgement Type a -> tcm MetaId+newMeta :: MetaInfo -> MetaPriority -> Permutation -> Judgement Type a -> TCM MetaId newMeta = newMeta' Open -newMeta' :: MonadTCM tcm => MetaInstantiation -> MetaInfo -> MetaPriority -> Permutation ->-            Judgement Type a -> tcm MetaId+-- | Generate a new meta variable with some instantiation given.+--   For instance, the instantiation could be a 'PostponedTypeCheckingProblem'.+newMeta' :: MetaInstantiation -> MetaInfo -> MetaPriority -> Permutation ->+            Judgement Type a -> TCM MetaId newMeta' inst mi p perm j = do   x <- fresh-  let mv = MetaVar mi p perm (fmap (const x) j) inst Set.empty+  let j' = fmap (const x) j  -- fill the identifier part of the judgement+      mv = MetaVar mi p perm j' inst Set.empty Instantiable+  -- printing not available (import cycle)+  -- reportSDoc "tc.meta.new" 50 $ text "new meta" <+> prettyTCM j'   modify $ \st -> st { stMetaStore = Map.insert x mv $ stMetaStore st }   return x -getInteractionRange :: MonadTCM tcm => InteractionId -> tcm Range+getInteractionRange :: InteractionId -> TCM Range getInteractionRange ii = do     mi <- lookupInteractionId ii     getMetaRange mi -getMetaRange :: MonadTCM tcm => MetaId -> tcm Range+getMetaRange :: MetaId -> TCM Range getMetaRange mi = getRange <$> lookupMeta mi  -getInteractionScope :: MonadTCM tcm => InteractionId -> tcm ScopeInfo+getInteractionScope :: InteractionId -> TCM ScopeInfo getInteractionScope ii =     do mi <- lookupInteractionId ii        mv <- lookupMeta mi        return $ getMetaScope mv -withMetaInfo :: MonadTCM tcm => MetaInfo -> tcm a -> tcm a+withMetaInfo :: MetaInfo -> TCM a -> TCM a withMetaInfo mI m = enterClosure mI $ \r -> setCurrentRange r m -getInstantiatedMetas :: MonadTCM tcm => tcm [MetaId]+getInstantiatedMetas :: TCM [MetaId] getInstantiatedMetas = do     store <- getMetaStore     return [ i | (i, MetaVar{ mvInstantiation = mi }) <- Map.assocs store, isInst mi ]     where 	isInst Open                             = False+	isInst OpenIFS                          = False 	isInst (BlockedConst _)                 = False         isInst (PostponedTypeCheckingProblem _) = False 	isInst (InstV _)                        = True 	isInst (InstS _)                        = True -getOpenMetas :: MonadTCM tcm => tcm [MetaId]+getOpenMetas :: TCM [MetaId] getOpenMetas = do     store <- getMetaStore     return [ i | (i, MetaVar{ mvInstantiation = mi }) <- Map.assocs store, isOpen mi ]     where 	isOpen Open                             = True+	isOpen OpenIFS                          = True 	isOpen (BlockedConst _)                 = True         isOpen (PostponedTypeCheckingProblem _) = True 	isOpen (InstV _)                        = False@@ -160,19 +171,35 @@  -- | @listenToMeta l m@: register @l@ as a listener to @m@. This is done --   when the type of l is blocked by @m@.-listenToMeta :: MonadTCM tcm => MetaId -> MetaId -> tcm ()+listenToMeta :: Listener -> MetaId -> TCM () listenToMeta l m =   updateMetaVar m $ \mv -> mv { mvListeners = Set.insert l $ mvListeners mv }  -- | Unregister a listener.-unlistenToMeta :: MonadTCM tcm => MetaId -> MetaId -> tcm ()+unlistenToMeta :: Listener -> MetaId -> TCM () unlistenToMeta l m =   updateMetaVar m $ \mv -> mv { mvListeners = Set.delete l $ mvListeners mv }  -- | Get the listeners to a meta.-getMetaListeners :: MonadTCM tcm => MetaId -> tcm [MetaId]+getMetaListeners :: MetaId -> TCM [Listener] getMetaListeners m = Set.toList . mvListeners <$> lookupMeta m -clearMetaListeners :: MonadTCM tcm => MetaId -> tcm ()+clearMetaListeners :: MetaId -> TCM () clearMetaListeners m =   updateMetaVar m $ \mv -> mv { mvListeners = Set.empty }++-- | Freeze all meta variables.+freezeMetas :: TCM ()+freezeMetas = modifyMetaStore $ Map.map freeze where+  freeze :: MetaVariable -> MetaVariable+  freeze mvar = mvar { mvFrozen = Frozen }++unfreezeMetas :: TCM ()+unfreezeMetas = modifyMetaStore $ Map.map unfreeze where+  unfreeze :: MetaVariable -> MetaVariable+  unfreeze mvar = mvar { mvFrozen = Instantiable }++isFrozen :: MetaId -> TCM Bool+isFrozen x = do+  mvar <- lookupMeta x+  return $ mvFrozen mvar == Frozen

src/full/Agda/TypeChecking/Monad/Mutual.hs view

@@ -16,10 +16,10 @@  #include "../../undefined.h" -noMutualBlock :: MonadTCM tcm => tcm a -> tcm a+noMutualBlock :: TCM a -> TCM a noMutualBlock = local $ \e -> e { envMutualBlock = Nothing } -inMutualBlock :: MonadTCM tcm => tcm a -> tcm a+inMutualBlock :: TCM a -> TCM a inMutualBlock m = do   mi <- asks envMutualBlock   case mi of@@ -30,7 +30,7 @@     Just _  -> m  -- | Set the mutual block for a definition-setMutualBlock :: MonadTCM tcm => MutualId -> QName -> tcm ()+setMutualBlock :: MutualId -> QName -> TCM () setMutualBlock i x = do   modify $ \s -> s { stMutualBlocks = Map.insertWith Set.union i (Set.singleton x) $ stMutualBlocks s 		   , stSignature    = (stSignature s)@@ -41,21 +41,21 @@     setMutId x i = flip Map.adjust x $ \defn -> defn { defMutual = i }  -- | Get all mutual blocks-getMutualBlocks :: MonadTCM tcm => tcm [Set QName]+getMutualBlocks :: TCM [Set QName] getMutualBlocks = gets $ Map.elems . stMutualBlocks  -- | Get the current mutual block.-currentMutualBlock :: MonadTCM tcm => tcm MutualId+currentMutualBlock :: TCM MutualId currentMutualBlock = maybe fresh return =<< asks envMutualBlock -lookupMutualBlock :: MonadTCM tcm => MutualId -> tcm (Set QName)+lookupMutualBlock :: MutualId -> TCM (Set QName) lookupMutualBlock mi = do   mb <- gets stMutualBlocks   case Map.lookup mi mb of     Just qs -> return qs-    Nothing -> fail $ "No such mutual block: " ++ show mi+    Nothing -> return Set.empty -- can end up here if we ask for the current mutual block and there is none -findMutualBlock :: MonadTCM tcm => QName -> tcm (Set QName)+findMutualBlock :: QName -> TCM (Set QName) findMutualBlock f = do   bs <- getMutualBlocks   case filter (Set.member f) bs of

src/full/Agda/TypeChecking/Monad/Open.hs view

@@ -23,7 +23,7 @@ import Agda.Utils.Impossible  -- | Create an open term in the current context.-makeOpen :: MonadTCM tcm => a -> tcm (Open a)+makeOpen :: a -> TCM (Open a) makeOpen x = do     ctx <- getContextId     return $ OpenThing ctx x@@ -35,14 +35,14 @@  -- | Extract the value from an open term. Must be done in an extension of the --   context in which the term was created.-getOpen :: (MonadTCM tcm, Raise a) => Open a -> tcm a+getOpen :: Raise a => Open a -> TCM a getOpen (OpenThing []  x) = return x getOpen (OpenThing ctx x) = do   ctx' <- getContextId   unless (ctx `isSuffixOf` ctx') $ fail $ "thing out of context (" ++ show ctx ++ " is not a sub context of " ++ show ctx' ++ ")"   return $ raise (genericLength ctx' - genericLength ctx) x -tryOpen :: (MonadTCM tcm, Raise a) => Open a -> tcm (Maybe a)-tryOpen o = liftTCM $+tryOpen :: Raise a => Open a -> TCM (Maybe a)+tryOpen o =   (Just <$> getOpen o)   `catchError` \_ -> return Nothing

src/full/Agda/TypeChecking/Monad/Options.hs view

@@ -26,24 +26,28 @@  -- | Sets the pragma options. -setPragmaOptions :: MonadTCM tcm => PragmaOptions -> tcm ()+setPragmaOptions :: PragmaOptions -> TCM () setPragmaOptions opts = do   clo <- commandLineOptions+  let unsafe = unsafePragmaOptions opts+  when (optSafe clo && not (null unsafe)) $ typeError (SafeFlagPragma unsafe)   case checkOpts (clo { optPragmaOptions = opts }) of     Left err   -> __IMPOSSIBLE__     Right opts -> do       modify $ \s -> s { stPragmaOptions = (optPragmaOptions opts) }+ -- | Sets the command line options (both persistent and pragma options -- are updated). -- -- Relative include directories are made absolute with respect to the--- current working directory. If the include directories have changed,--- then the state is reset.+-- current working directory. If the include directories have changed+-- (and were previously @'Right' something@), then the state is reset+-- (completely) . -- -- An empty list of relative include directories (@'Left' []@) is -- interpreted as @["."]@. -setCommandLineOptions :: MonadTCM tcm => CommandLineOptions -> tcm ()+setCommandLineOptions :: CommandLineOptions -> TCM () setCommandLineOptions opts =   case checkOpts opts of     Left err   -> __IMPOSSIBLE__@@ -54,24 +58,26 @@           setIncludeDirs is CurrentDir           getIncludeDirs       modify $ \s ->-        s { stPersistentOptions = opts { optIncludeDirs = Right incs }-          , stPragmaOptions     = optPragmaOptions opts+        s { stPersistent = (stPersistent s) {+              stPersistentOptions = opts { optIncludeDirs = Right incs }+            }+          , stPragmaOptions = optPragmaOptions opts           }  -- | Returns the pragma options which are currently in effect. -pragmaOptions :: MonadTCM tcm => tcm PragmaOptions-pragmaOptions = liftTCM $ gets stPragmaOptions+pragmaOptions :: TCM PragmaOptions+pragmaOptions = gets stPragmaOptions  -- | Returns the command line options which are currently in effect. -commandLineOptions :: MonadTCM tcm => tcm CommandLineOptions-commandLineOptions = liftTCM $ do-  p  <- gets stPragmaOptions-  cl <- gets stPersistentOptions+commandLineOptions :: TCM CommandLineOptions+commandLineOptions = do+  p  <- stPragmaOptions <$> get+  cl <- stPersistentOptions . stPersistent <$> get   return $ cl { optPragmaOptions = p } -setOptionsFromPragma :: MonadTCM tcm => OptionsPragma -> tcm ()+setOptionsFromPragma :: OptionsPragma -> TCM () setOptionsFromPragma ps = do     opts <- commandLineOptions     case parsePragmaOptions ps opts of@@ -79,43 +85,44 @@ 	Right opts' -> setPragmaOptions opts'  -- | Disable display forms.-enableDisplayForms :: MonadTCM tcm => tcm a -> tcm a+enableDisplayForms :: TCM a -> TCM a enableDisplayForms =   local $ \e -> e { envDisplayFormsEnabled = True }  -- | Disable display forms.-disableDisplayForms :: MonadTCM tcm => tcm a -> tcm a+disableDisplayForms :: TCM a -> TCM a disableDisplayForms =   local $ \e -> e { envDisplayFormsEnabled = False }  -- | Check if display forms are enabled.-displayFormsEnabled :: MonadTCM tcm => tcm Bool+displayFormsEnabled :: TCM Bool displayFormsEnabled = asks envDisplayFormsEnabled  -- | Don't eta contract implicit-dontEtaContractImplicit :: MonadTCM tcm => tcm a -> tcm a+dontEtaContractImplicit :: TCM a -> TCM a dontEtaContractImplicit = local $ \e -> e { envEtaContractImplicit = False }  -- | Do eta contract implicit+{-# SPECIALIZE doEtaContractImplicit :: TCM a -> TCM a #-} doEtaContractImplicit :: MonadTCM tcm => tcm a -> tcm a doEtaContractImplicit = local $ \e -> e { envEtaContractImplicit = True } -shouldEtaContractImplicit :: MonadTCM tcm => tcm Bool+shouldEtaContractImplicit :: TCM Bool shouldEtaContractImplicit = asks envEtaContractImplicit  -- | Don't reify interaction points-dontReifyInteractionPoints :: MonadTCM tcm => tcm a -> tcm a+dontReifyInteractionPoints :: TCM a -> TCM a dontReifyInteractionPoints =   local $ \e -> e { envReifyInteractionPoints = False } -shouldReifyInteractionPoints :: MonadTCM tcm => tcm Bool+shouldReifyInteractionPoints :: TCM Bool shouldReifyInteractionPoints = asks envReifyInteractionPoints  -- | Gets the include directories. -- -- Precondition: 'optIncludeDirs' must be @'Right' something@. -getIncludeDirs :: MonadTCM tcm => tcm [AbsolutePath]+getIncludeDirs :: TCM [AbsolutePath] getIncludeDirs = do   incs <- optIncludeDirs <$> commandLineOptions   case incs of@@ -135,17 +142,18 @@ -- | Makes the given directories absolute and stores them as include -- directories. ----- If the include directories have changed, then the state is reset.+-- If the include directories change (and they were previously+-- @'Right' something@), then the state is reset (completely, except+-- for the include directories). -- -- An empty list is interpreted as @["."]@.  setIncludeDirs-  :: MonadTCM tcm-  => [FilePath]+  :: [FilePath]   -- ^ New include directories.   -> RelativeTo   -- ^ How should relative paths be interpreted?-  -> tcm ()+  -> TCM () setIncludeDirs incs relativeTo = do   opts <- commandLineOptions   let oldIncs = optIncludeDirs opts@@ -155,50 +163,59 @@       root <- liftIO (absolute =<< getCurrentDirectory)       return (root, return ())     ProjectRoot f -> do-      m <- liftTCM $ moduleName' f-      return (projectRoot f m, liftTCM $ checkModuleName m f)+      m <- moduleName' f+      return (projectRoot f m, checkModuleName m f) -  modify $ \s -> s { stPersistentOptions =-    (stPersistentOptions s) { optIncludeDirs =-      Right $ map (mkAbsolute . (filePath root </>)) $-        case incs of-          [] -> ["."]-          _  -> incs } }+  let setIncs incs = modify $ \s ->+        s { stPersistent =+          (stPersistent s) { stPersistentOptions =+            (stPersistentOptions $ stPersistent s)+              { optIncludeDirs = Right incs+            }+          }+        } +  setIncs (map (mkAbsolute . (filePath root </>)) $+             case incs of+               [] -> ["."]+               _  -> incs)+   incs <- getIncludeDirs   case oldIncs of-    Right incs' | incs' /= incs -> resetState+    Right incs' | incs' /= incs -> do+      resetAllState+      setIncs incs     _                           -> return ()    check -setInputFile :: MonadTCM tcm => FilePath -> tcm ()+setInputFile :: FilePath -> TCM () setInputFile file =     do	opts <- commandLineOptions 	setCommandLineOptions $           opts { optInputFile = Just file }  -- | Should only be run if 'hasInputFile'.-getInputFile :: MonadTCM tcm => tcm AbsolutePath+getInputFile :: TCM AbsolutePath getInputFile =     do	mf <- optInputFile <$> commandLineOptions 	case mf of 	    Just file -> liftIO $ absolute file 	    Nothing   -> __IMPOSSIBLE__ -hasInputFile :: MonadTCM tcm => tcm Bool+hasInputFile :: TCM Bool hasInputFile = isJust <$> optInputFile <$> commandLineOptions -proofIrrelevance :: MonadTCM tcm => tcm Bool+proofIrrelevance :: TCM Bool proofIrrelevance = optProofIrrelevance <$> pragmaOptions -hasUniversePolymorphism :: MonadTCM tcm => tcm Bool+hasUniversePolymorphism :: TCM Bool hasUniversePolymorphism = optUniversePolymorphism <$> pragmaOptions -showImplicitArguments :: MonadTCM tcm => tcm Bool+showImplicitArguments :: TCM Bool showImplicitArguments = optShowImplicit <$> pragmaOptions -setShowImplicitArguments :: MonadTCM tcm => Bool -> tcm a -> tcm a+setShowImplicitArguments :: Bool -> TCM a -> TCM a setShowImplicitArguments showImp ret = do   opts <- pragmaOptions   let imp = optShowImplicit opts@@ -208,21 +225,21 @@   setPragmaOptions $ opts { optShowImplicit = imp }   return x -ignoreInterfaces :: MonadTCM tcm => tcm Bool+ignoreInterfaces :: TCM Bool ignoreInterfaces = optIgnoreInterfaces <$> commandLineOptions -positivityCheckEnabled :: MonadTCM tcm => tcm Bool+positivityCheckEnabled :: TCM Bool positivityCheckEnabled = not . optDisablePositivity <$> pragmaOptions -typeInType :: MonadTCM tcm => tcm Bool+typeInType :: TCM Bool typeInType = not . optUniverseCheck <$> pragmaOptions -getVerbosity :: MonadTCM tcm => tcm (Trie String Int)+getVerbosity :: TCM (Trie String Int) getVerbosity = optVerbose <$> pragmaOptions  type VerboseKey = String -hasVerbosity :: MonadTCM tcm => VerboseKey -> Int -> tcm Bool+hasVerbosity :: VerboseKey -> Int -> TCM Bool hasVerbosity k n | n < 0     = __IMPOSSIBLE__                  | otherwise = do     t <- getVerbosity@@ -231,24 +248,23 @@     return (n <= m)  -- | Precondition: The level must be non-negative.-verboseS :: MonadTCM tcm => VerboseKey -> Int -> tcm () -> tcm ()+verboseS :: VerboseKey -> Int -> TCM () -> TCM () verboseS k n action = whenM (hasVerbosity k n) action -reportS :: MonadTCM tcm => VerboseKey -> Int -> String -> tcm ()+reportS :: VerboseKey -> Int -> String -> TCM () reportS k n s = verboseS k n $ liftIO $ LocIO.putStr s -reportSLn :: MonadTCM tcm => VerboseKey -> Int -> String -> tcm ()+reportSLn :: VerboseKey -> Int -> String -> TCM () reportSLn k n s = verboseS k n $ liftIO $ LocIO.putStrLn s >> LocIO.stdoutFlush -reportSDoc :: MonadTCM tcm => VerboseKey -> Int -> tcm Doc -> tcm ()+reportSDoc :: VerboseKey -> Int -> TCM Doc -> TCM () reportSDoc k n d = verboseS k n $ liftIO . LocIO.print =<< d -verboseBracket :: MonadTCM tcm => VerboseKey -> Int -> String -> tcm a -> tcm a+verboseBracket :: VerboseKey -> Int -> String -> TCM a -> TCM a verboseBracket k n s m = do   v <- hasVerbosity k n   if not v then m            else do     liftIO $ LocIO.putStrLn $ "{ " ++ s-    x <- m-    liftIO $ LocIO.putStrLn "}"+    x <- m `finally` liftIO (LocIO.putStrLn "}")     return x

src/full/Agda/TypeChecking/Monad/Options.hs-boot view

@@ -3,4 +3,4 @@ import Agda.TypeChecking.Monad.Base import Agda.Utils.FileName -getIncludeDirs :: MonadTCM tcm => tcm [AbsolutePath]+getIncludeDirs :: TCM [AbsolutePath]

src/full/Agda/TypeChecking/Monad/Signature.hs view

@@ -1,6 +1,7 @@ {-# LANGUAGE CPP, PatternGuards #-} module Agda.TypeChecking.Monad.Signature where +import Control.Arrow ((***)) import Control.Monad.State import Control.Monad.Reader import Data.Set (Set)@@ -16,15 +17,18 @@ import Agda.Syntax.Internal import Agda.Syntax.Position +import qualified Agda.Compiler.JS.Parser as JS+ import Agda.TypeChecking.Monad.Base import Agda.TypeChecking.Monad.Context import Agda.TypeChecking.Monad.Options import Agda.TypeChecking.Monad.Env import Agda.TypeChecking.Monad.Mutual import Agda.TypeChecking.Monad.Open+import Agda.TypeChecking.Free (isBinderUsed) import Agda.TypeChecking.Substitute -- import Agda.TypeChecking.Pretty -- leads to cyclicity-import Agda.TypeChecking.CompiledClause+import {-# SOURCE #-} Agda.TypeChecking.CompiledClause.Compile import {-# SOURCE #-} Agda.TypeChecking.Polarity  import Agda.Utils.Monad@@ -36,25 +40,25 @@ #include "../../undefined.h" import Agda.Utils.Impossible -modifySignature :: MonadTCM tcm => (Signature -> Signature) -> tcm ()+modifySignature :: (Signature -> Signature) -> TCM () modifySignature f = modify $ \s -> s { stSignature = f $ stSignature s } -modifyImportedSignature :: MonadTCM tcm => (Signature -> Signature) -> tcm ()+modifyImportedSignature :: (Signature -> Signature) -> TCM () modifyImportedSignature f = modify $ \s -> s { stImports = f $ stImports s } -getSignature :: MonadTCM tcm => tcm Signature-getSignature = liftTCM $ gets stSignature+getSignature :: TCM Signature+getSignature = gets stSignature -getImportedSignature :: MonadTCM tcm => tcm Signature-getImportedSignature = liftTCM $ gets stImports+getImportedSignature :: TCM Signature+getImportedSignature = gets stImports -setSignature :: MonadTCM tcm => Signature -> tcm ()+setSignature :: Signature -> TCM () setSignature sig = modifySignature $ const sig -setImportedSignature :: MonadTCM tcm => Signature -> tcm ()-setImportedSignature sig = liftTCM $ modify $ \s -> s { stImports = sig }+setImportedSignature :: Signature -> TCM ()+setImportedSignature sig = modify $ \s -> s { stImports = sig } -withSignature :: MonadTCM tcm => Signature -> tcm a -> tcm a+withSignature :: Signature -> TCM a -> TCM a withSignature sig m =     do	sig0 <- getSignature 	setSignature sig@@ -63,8 +67,8 @@         return r  -- | Add a constant to the signature. Lifts the definition to top level.-addConstant :: MonadTCM tcm => QName -> Definition -> tcm ()-addConstant q d = liftTCM $ do+addConstant :: QName -> Definition -> TCM ()+addConstant q d = do   reportSLn "tc.signature" 20 $ "adding constant " ++ show q ++ " to signature"   tel <- getContextTelescope   let tel' = killRange $ case theDef d of@@ -82,31 +86,114 @@     hideTel  EmptyTel		      = EmptyTel     hideTel (ExtendTel (Arg _ r t) tel) = ExtendTel (Arg Hidden r t) $ hideTel <$> tel -addHaskellCode :: MonadTCM tcm => QName -> HaskellType -> HaskellCode -> tcm ()+-- | Turn a definition into a projection if it looks like a projection.+makeProjection :: QName -> TCM ()+makeProjection x = inContext [] $ do+  reportSLn "tc.proj.like" 30 $ "Considering " ++ show x ++ " for projection likeness"+  defn <- getConstInfo x+  case theDef defn of+    -- Constructor-headed functions can't be projection-like (at the moment). The reason+    -- for this is that invoking constructor-headedness will circumvent the inference of+    -- the dropped arguments.+    -- Nor can abstract definitions be projection-like since they won't reduce+    -- outside the abstract block.+    def@Function{funProjection = Nothing, funClauses = cls, funInv = NotInjective,+                 funAbstr = ConcreteDef} -> do+      ps0 <- filterM validProj (candidateArgs [] (unEl $ defType defn))+      reportSLn "tc.proj.like" 30 $ if null ps0 then "  no candidates found"+                                                else "  candidates: " ++ show ps0+      ps <- return $ filter (checkOccurs cls . snd) ps0+      when (not (null ps0) && null ps) $ reportSLn "tc.proj.like" 50 $ "  occurs check failed\n    clauses = " ++ show cls+      case reverse ps of+        []         -> return ()+        (d, n) : _ -> do+          reportSLn "tc.proj.like" 10 $ show (defName defn) ++ " is projection like in argument " +++                                        show n ++ " for type " ++ show d+          let cls' = map (rewriteClause n) cls+          cc <- compileClauses True cls'+          reportSLn "tc.proj.like" 20 $ "  rewrote clauses to\n    " ++ show cc+          let mapInv f NotInjective  = NotInjective+              mapInv f (Inverse inv) = Inverse (f inv)+              newDef = def+                       { funProjection     = Just (d, n + 1)+                       , funClauses        = cls'+                       , funCompiled       = cc+                       , funInv            = mapInv (Map.map $ rewriteClause n) $ funInv def+                       , funArgOccurrences = drop n $ funArgOccurrences def+                       , funPolarity       = drop n $ funPolarity def+                       }+          addConstant x $ defn{ theDef     = newDef+                              , defDisplay = [] }+    _ -> return ()+  where+    validProj (_, 0) = return False+    validProj (d, _) = do+      defn <- theDef <$> getConstInfo d+      return $ case defn of+        Datatype{} -> True+        Record{}   -> True+        Axiom{}    -> True+        _          -> False++    rewriteClause n cl@Clause{clausePerm = Perm m p} =+      cl{ clausePerm = Perm (m - fromIntegral n) $ map (subtract $ fromIntegral n) $ drop n p+        , clauseTel  = telFromList $ drop n $ telToList $ clauseTel cl+        , clausePats = drop n $ clausePats cl+        , clauseBody = dropB n $ clauseBody cl+        }+      where+        dropB 0 b          = b+        dropB _ NoBody     = NoBody+        dropB n (Bind b)   = dropB (n - 1) (absBody b)+        dropB n Body{}     = __IMPOSSIBLE__++    checkOccurs cls n = all (nonOccur n) cls++    nonOccur n Clause{clausePerm = Perm _ p, clausePats = ps, clauseBody = b} =+      and [ take n p == [0..fromIntegral n - 1]+          , onlyMatch n ps  -- projection-like functions are only allowed to match on the eliminatee+                            -- otherwise we may end up projecting from constructor applications, in+                            -- which case we can't reconstruct the dropped parameters+          , checkBody n b ]++    onlyMatch n ps = all (noMatch . unArg) $ ps0 ++ drop 1 ps1+      where+        (ps0, ps1) = splitAt n ps+        noMatch ConP{} = False+        noMatch LitP{} = False+        noMatch VarP{} = True+        noMatch DotP{} = True++    checkBody 0 _          = True+    checkBody _ NoBody     = True+    checkBody n (Bind b)   = not (isBinderUsed b) && checkBody (n - 1) (unAbs b)+    checkBody _ Body{}     = __IMPOSSIBLE__++    candidateArgs vs (Pi (Arg r h (El _ (Def d us))) b)+      | vs == map unArg us = (d, length vs) : candidateRec vs b+    candidateArgs vs (Pi _ b) = candidateRec vs b+    candidateArgs _ _ = []++    candidateRec vs NoAbs{} = []+    candidateRec vs b       = candidateArgs (Var (size vs) [] : vs) (unEl $ absBody b)++addHaskellCode :: QName -> HaskellType -> HaskellCode -> TCM () addHaskellCode q hsTy hsDef =   -- TODO: sanity checking   modifySignature $ \sig -> sig   { sigDefinitions = Map.adjust addHs q $ sigDefinitions sig }   where-    addHs def@Defn{theDef = con@Constructor{}} =-      def{theDef = con{conHsCode = Just (hsTy, hsDef)}}-    addHs def@Defn{theDef = ax@Axiom{}} =-      def{theDef = ax{axHsDef = Just $ HsDefn hsTy hsDef}}-    addHs def = def+    addHs def = def { defCompiledRep = (defCompiledRep def) { compiledHaskell = Just $ HsDefn hsTy hsDef } } -addHaskellType :: MonadTCM tcm => QName -> HaskellType -> tcm ()+addHaskellType :: QName -> HaskellType -> TCM () addHaskellType q hsTy =   -- TODO: sanity checking   modifySignature $ \sig -> sig   { sigDefinitions = Map.adjust addHs q $ sigDefinitions sig }   where-    addHs def@Defn{theDef = ax@Axiom{}} =-      def{theDef = ax{axHsDef = Just $ HsType hsTy}}-    addHs def@Defn{theDef = d@Datatype{}} =-      def{theDef = d{dataHsType = Just hsTy}}-    addHs def = def+    addHs def = def { defCompiledRep = (defCompiledRep def) { compiledHaskell = Just $ HsType hsTy } } -addEpicCode :: MonadTCM tcm => QName -> EpicCode -> tcm ()+addEpicCode :: QName -> EpicCode -> TCM () addEpicCode q epDef =   -- TODO: sanity checking   modifySignature $ \sig -> sig@@ -114,17 +201,35 @@   where     --addEp def@Defn{theDef = con@Constructor{}} =       --def{theDef = con{conHsCode = Just (hsTy, hsDef)}}-    addEp def@Defn{theDef = ax@Axiom{}} =-      def{theDef = ax{axEpDef = Just $ epDef}}-    addEp def = def+    addEp def = def { defCompiledRep = (defCompiledRep def) { compiledEpic = Just epDef } } +addJSCode :: QName -> String -> TCM ()+addJSCode q jsDef =+  case JS.parse jsDef of+    Left e ->+      modifySignature $ \sig -> sig+      { sigDefinitions = Map.adjust (addJS (Just e)) q $ sigDefinitions sig }+    Right s ->+      typeError (CompilationError ("Failed to parse ECMAScript (..." ++ s ++ ") for " ++ show q))+  where+    addJS e def = def{defCompiledRep = (defCompiledRep def){compiledJS = e}}++markStatic :: QName -> TCM ()+markStatic q =+  modifySignature $ \sig -> sig+  { sigDefinitions = Map.adjust mark q $ sigDefinitions sig }+  where+    mark def@Defn{theDef = fun@Function{}} =+      def{theDef = fun{funStatic = True}}+    mark def = def+ unionSignatures :: [Signature] -> Signature unionSignatures ss = foldr unionSignature emptySignature ss   where     unionSignature (Sig a b) (Sig c d) = Sig (Map.union a c) (Map.union b d)  -- | Add a section to the signature.-addSection :: MonadTCM tcm => ModuleName -> Nat -> tcm ()+addSection :: ModuleName -> Nat -> TCM () addSection m fv = do   tel <- getContextTelescope   let sec = Section tel fv@@ -132,7 +237,7 @@  -- | Lookup a section. If it doesn't exist that just means that the module --   wasn't parameterised.-lookupSection :: MonadTCM tcm => ModuleName -> tcm Telescope+lookupSection :: ModuleName -> TCM Telescope lookupSection m = do   sig  <- sigSections <$> getSignature   isig <- sigSections <$> getImportedSignature@@ -145,15 +250,20 @@   add args x x []   where     add args top x ps = do-      cs <- map originalClause . defClauses <$> getConstInfo x+      def <- getConstInfo x+      let cs = defClauses def+          n  = case theDef def of+                 Function{ funProjection = Just (_, n) } -> n+                 _ -> 0       case cs of 	[ Clause{ clauseBody = b } ]-	  | Just (m, Def y vs) <- strip b-	  , m == length args && args `isPrefixOf` vs -> do+	  | Just (m, Def y vs) <- strip b -> do 	      let ps' = raise 1 (map unArg vs) ++ ps-	      reportSLn "tc.section.apply.display" 20 $ "adding display form " ++ show y ++ " --> " ++ show top-	      addDisplayForm y (Display 0 ps' $ DTerm $ Def top args)-	      add args top y $ drop (length args) ps'+                  df  = Display 0 ps' $ DTerm $ Def top (drop (n - 1) args)+	      reportSLn "tc.display.section" 20 $ "adding display form " ++ show y ++ " --> " ++ show top+                                                ++ "\n  " ++ show df+	      addDisplayForm y df+	      add args top y ps' 	_ -> do 	      let reason = case cs of 		    []    -> "no clauses"@@ -163,28 +273,20 @@ 		      Just (m, Def y vs) 			| m < length args -> "too few args" 			| m > length args -> "too many args"-			| otherwise	      -> "args=" ++ unwords (map var args) ++ " vs=" ++ unwords (map var vs)-			  where-			    var (Arg h r x) = hid h $ case x of-			      Var i []	-> show i-			      MetaV _ _	-> "?"-			      _		-> "_"-			    hid NotHidden s = s-			    hid Hidden    s = "{" ++ s ++ "}"+			| otherwise	      -> "args=" ++ show args ++ " vs=" ++ show vs 		      Just (m, v) -> "not a def body"-	      reportSLn "tc.section.apply.display" 30 $ "no display form from" ++ show x ++ " because " ++ reason+	      reportSLn "tc.display.section" 30 $ "no display form from" ++ show x ++ " because " ++ reason 	      return ()     strip (Body v)   = return (0, v)     strip  NoBody    = Nothing-    strip (NoBind b) = Nothing     strip (Bind b)   = do       (n, v) <- strip $ absBody b       return (n + 1, v)  applySection ::-  MonadTCM tcm => ModuleName -> Telescope -> ModuleName -> Args ->-  Map QName QName -> Map ModuleName ModuleName -> tcm ()-applySection new ptel old ts rd rm = liftTCM $ do+  ModuleName -> Telescope -> ModuleName -> Args ->+  Map QName QName -> Map ModuleName ModuleName -> TCM ()+applySection new ptel old ts rd rm = do   sig  <- getSignature   isig <- getImportedSignature   let ss = getOld partOfOldM sigSections    [sig, isig]@@ -203,6 +305,7 @@     ]   mapM_ (copyDef ts) ds   mapM_ (copySec ts) ss+  mapM_ computePolarity (Map.elems rd)   where     getOld partOfOld fromSig sigs =       Map.toList $ Map.filterKeys partOfOld $ Map.unions $ map fromSig sigs@@ -217,51 +320,68 @@ 	Nothing -> return ()  -- if it's not in the renaming it was private and 			      -- we won't need it 	Just y	-> do-	  addConstant y (nd y)-          computePolarity y  -- AA: Polarity.sizePolarity needs also constructor names+	  addConstant y =<< nd y+          makeProjection y 	  -- Set display form for the old name if it's not a constructor. 	  unless (isCon || size ptel > 0) $ do 	    addDisplayForms y       where 	t  = defType d `apply` ts 	-- the name is set by the addConstant function-	nd y = Defn (defRelevance d) y t [] (-1) def  -- TODO: mutual block?+	nd y = Defn (defRelevance d) y t [] (-1) noCompiledRep <$> def  -- TODO: mutual block?         oldDef = theDef d 	isCon = case oldDef of 	  Constructor{} -> True 	  _		-> False-        -- TODO: compute polarity for the new definition+        getOcc d = case d of+          Function { funArgOccurrences  = os } -> os+          Datatype { dataArgOccurrences = os } -> os+          Record   { recArgOccurrences  = os } -> os+          _ -> []+        oldOcc = getOcc oldDef 	def  = case oldDef of-                Constructor{ conPars = np, conData = d } ->+                Constructor{ conPars = np, conData = d } -> return $                   oldDef { conPars = np - size ts, conData = copyName d }-                Datatype{ dataPars = np, dataCons = cs } ->-                  oldDef { dataPars = np - size ts, dataClause = Just cl, dataCons = map copyName cs }-                Record{ recPars = np, recConType = t, recTel = tel } ->+                Datatype{ dataPars = np, dataCons = cs } -> return $+                  oldDef { dataPars = np - size ts, dataClause = Just cl, dataCons = map copyName cs+                         , dataArgOccurrences = drop (length ts) oldOcc }+                Record{ recPars = np, recConType = t, recTel = tel } -> return $                   oldDef { recPars = np - size ts, recClause = Just cl                          , recConType = apply t ts, recTel = apply tel ts+                         , recArgOccurrences = drop (length ts) oldOcc                          }-		_ ->-                  Function { funClauses        = [cl2]-                           , funCompiled       = cc-                           , funDelayed        = NotDelayed-                           , funInv            = NotInjective-                           , funPolarity       = []-                           , funArgOccurrences = []-                           , funAbstr          = ConcreteDef-                           , funProjection     = fmap (nonNeg . \ n -> n - size ts) maybeNum-                           }-                  where maybeNum = case oldDef of-                                     Function { funProjection = mn } -> mn-                                     _                               -> Nothing-                        nonNeg n = if n >= 0 then n else __IMPOSSIBLE__+		_ -> do+                  cc <- compileClauses True [cl]+                  let newDef = Function+                        { funClauses        = [cl]+                        , funCompiled       = cc+                        , funDelayed        = NotDelayed+                        , funInv            = NotInjective+                        , funPolarity       = []+                        , funArgOccurrences = drop (length ts') oldOcc+                        , funAbstr          = ConcreteDef+                        , funProjection     = proj+                        , funStatic         = False+                        }+                  reportSLn "tc.mod.apply" 80 $ "new def for " ++ show x ++ "\n  " ++ show newDef+                  return newDef+                  where+                    proj = case oldDef of+                      Function{funProjection = Just (r, n)}+                        | size ts < n -> Just (r, n - size ts)+                      _ -> Nothing+        ts' | null ts   = []+            | otherwise = case oldDef of+                Function{funProjection = Just (_, n)}+                  | n == 0       -> __IMPOSSIBLE__+                  | otherwise    -> drop (n - 1) ts+                _ -> ts 	cl = Clause { clauseRange = getRange $ defClauses d                     , clauseTel   = EmptyTel                     , clausePerm  = idP 0                     , clausePats  = []-                    , clauseBody  = Body $ Def x ts+                    , clauseBody  = Body $ Def x ts'                     }-        cl2 = Clauses Nothing cl-        cc  = compileClauses [cl2]      copySec :: Args -> (ModuleName, Section) -> TCM ()     copySec ts (x, sec) = case Map.lookup x rm of@@ -272,7 +392,7 @@       where 	tel = secTelescope sec -addDisplayForm :: MonadTCM tcm => QName -> DisplayForm -> tcm ()+addDisplayForm :: QName -> DisplayForm -> TCM () addDisplayForm x df = do   d <- makeOpen df   modifyImportedSignature (add d)@@ -283,7 +403,7 @@ 	addDf def = def { defDisplay = df : defDisplay def } 	defs	  = sigDefinitions sig -canonicalName :: MonadTCM tcm => QName -> tcm QName+canonicalName :: QName -> TCM QName canonicalName x = do   def <- theDef <$> getConstInfo x   case def of@@ -292,15 +412,14 @@     Datatype{dataClause = Just (Clause{ clauseBody = body })} -> canonicalName $ extract body     _                                                         -> return x   where-    extract NoBody	     = __IMPOSSIBLE__+    extract NoBody           = __IMPOSSIBLE__     extract (Body (Def x _)) = x-    extract (Body _)	     = __IMPOSSIBLE__-    extract (Bind (Abs _ b)) = extract b-    extract (NoBind b)	     = extract b+    extract (Body _)         = __IMPOSSIBLE__+    extract (Bind b)         = extract (unAbs b)  -- | Can be called on either a (co)datatype, a record type or a --   (co)constructor.-whatInduction :: MonadTCM tcm => QName -> tcm Induction+whatInduction :: QName -> TCM Induction whatInduction c = do   def <- theDef <$> getConstInfo c   case def of@@ -327,6 +446,7 @@  -- | Lookup the definition of a name. The result is a closed thing, all free --   variables have been abstracted over.+{-# SPECIALIZE getConstInfo :: QName -> TCM Definition #-} getConstInfo :: MonadTCM tcm => QName -> tcm Definition getConstInfo q = liftTCM $ join $ pureTCM $ \st env ->   let defs  = sigDefinitions $ stSignature st@@ -359,8 +479,8 @@         init' xs = init xs  -- | Look up the polarity of a definition.-getPolarity :: MonadTCM tcm => QName -> tcm [Polarity]-getPolarity q = liftTCM $ do+getPolarity :: QName -> TCM [Polarity]+getPolarity q = do   defn <- theDef <$> getConstInfo q   case defn of     Function{ funPolarity  = p } -> return p@@ -368,13 +488,13 @@     Record{ recPolarity    = p } -> return p     _                            -> return [] -getPolarity' :: MonadTCM tcm => Comparison -> QName -> tcm [Polarity]+getPolarity' :: Comparison -> QName -> TCM [Polarity] getPolarity' CmpEq _  = return [] getPolarity' CmpLeq q = getPolarity q  -- | Set the polarity of a definition.-setPolarity :: MonadTCM tcm => QName -> [Polarity] -> tcm ()-setPolarity q pol = liftTCM $ do+setPolarity :: QName -> [Polarity] -> TCM ()+setPolarity q pol = do   modifySignature setP   where     setP sig = sig { sigDefinitions = Map.adjust setPx q defs }@@ -387,7 +507,7 @@           _          -> d 	defs	  = sigDefinitions sig -getArgOccurrence :: MonadTCM tcm => QName -> Nat -> tcm Occurrence+getArgOccurrence :: QName -> Nat -> TCM Occurrence getArgOccurrence d i = do   def <- theDef <$> getConstInfo d   return $ case def of@@ -399,8 +519,8 @@   where     look i os = (os ++ repeat Negative) !! fromIntegral i -setArgOccurrences :: MonadTCM tcm => QName -> [Occurrence] -> tcm ()-setArgOccurrences d os = liftTCM $+setArgOccurrences :: QName -> [Occurrence] -> TCM ()+setArgOccurrences d os =   modifySignature setO   where     setO sig = sig { sigDefinitions = Map.adjust setOx d defs }@@ -416,7 +536,7 @@  -- | Look up the number of free variables of a section. This is equal to the --   number of parameters if we're currently inside the section and 0 otherwise.-getSecFreeVars :: MonadTCM tcm => ModuleName -> tcm Nat+getSecFreeVars :: ModuleName -> TCM Nat getSecFreeVars m = do   sig  <- sigSections <$> getSignature   isig <- sigSections <$> getImportedSignature@@ -427,23 +547,23 @@  -- | Compute the number of free variables of a module. This is the sum of --   the free variables of its sections.-getModuleFreeVars :: MonadTCM tcm => ModuleName -> tcm Nat+getModuleFreeVars :: ModuleName -> TCM Nat getModuleFreeVars m = sum <$> ((:) <$> getAnonymousVariables m <*> mapM getSecFreeVars ms)   where     ms = map mnameFromList . inits . mnameToList $ m  -- | Compute the number of free variables of a defined name. This is the sum of --   the free variables of the sections it's contained in.-getDefFreeVars :: MonadTCM tcm => QName -> tcm Nat+getDefFreeVars :: QName -> TCM Nat getDefFreeVars q = getModuleFreeVars (qnameModule q)  -- | Compute the context variables to apply a definition to.-freeVarsToApply :: MonadTCM tcm => QName -> tcm Args+freeVarsToApply :: QName -> TCM Args freeVarsToApply x = genericTake <$> getDefFreeVars x <*> getContextArgs  -- | Instantiate a closed definition with the correct part of the current --   context.-instantiateDef :: MonadTCM tcm => Definition -> tcm Definition+instantiateDef :: Definition -> TCM Definition instantiateDef d = do   vs  <- freeVarsToApply $ defName d   verboseS "tc.sig.inst" 30 $ do@@ -458,27 +578,27 @@ makeAbstract d = do def <- makeAbs $ theDef d 		    return d { theDef = def }     where-	makeAbs Datatype   {dataAbstr = AbstractDef} = Just $ Axiom Nothing Nothing-	makeAbs Function   {funAbstr  = AbstractDef} = Just $ Axiom Nothing Nothing+	makeAbs Datatype   {dataAbstr = AbstractDef} = Just Axiom+	makeAbs Function   {funAbstr  = AbstractDef} = Just Axiom 	makeAbs Constructor{conAbstr  = AbstractDef} = Nothing 	makeAbs d                                    = Just d  -- | Enter abstract mode. Abstract definition in the current module are transparent.-inAbstractMode :: MonadTCM tcm => tcm a -> tcm a+inAbstractMode :: TCM a -> TCM a inAbstractMode = local $ \e -> e { envAbstractMode = AbstractMode }  -- | Not in abstract mode. All abstract definitions are opaque.-inConcreteMode :: MonadTCM tcm => tcm a -> tcm a+inConcreteMode :: TCM a -> TCM a inConcreteMode = local $ \e -> e { envAbstractMode = ConcreteMode }  -- | Ignore abstract mode. All abstract definitions are transparent.-ignoreAbstractMode :: MonadTCM tcm => tcm a -> tcm a+ignoreAbstractMode :: TCM a -> TCM a ignoreAbstractMode = local $ \e -> e { envAbstractMode = IgnoreAbstractMode }  -- | Check whether a name might have to be treated abstractly (either if we're --   'inAbstractMode' or it's not a local name). Returns true for things not --   declared abstract as well, but for those 'makeAbstract' will have no effect.-treatAbstractly :: MonadTCM tcm => QName -> tcm Bool+treatAbstractly :: QName -> TCM Bool treatAbstractly q = treatAbstractly' q <$> ask  treatAbstractly' :: QName -> TCEnv -> Bool@@ -491,15 +611,15 @@     m	    = qnameModule q  -- | get type of a constant-typeOfConst :: MonadTCM tcm => QName -> tcm Type+typeOfConst :: QName -> TCM Type typeOfConst q = defType <$> (instantiateDef =<< getConstInfo q)  -- | get relevance of a constant-relOfConst :: MonadTCM tcm => QName -> tcm Relevance+relOfConst :: QName -> TCM Relevance relOfConst q = defRelevance <$> getConstInfo q  -- | The name must be a datatype.-sortOfConst :: MonadTCM tcm => QName -> tcm Sort+sortOfConst :: QName -> TCM Sort sortOfConst q =     do	d <- theDef <$> getConstInfo q 	case d of@@ -507,7 +627,7 @@ 	    _			   -> fail $ "Expected " ++ show q ++ " to be a datatype."  -- | Is it the name of a record projection?-isProjection :: MonadTCM tcm => QName -> tcm (Maybe Int)+isProjection :: QName -> TCM (Maybe (QName, Int)) isProjection qn = do   def <- theDef <$> getConstInfo qn   case def of

src/full/Agda/TypeChecking/Monad/SizedTypes.hs view

@@ -1,6 +1,7 @@  module Agda.TypeChecking.Monad.SizedTypes where +import Control.Applicative import Control.Monad.Error  import Agda.Interaction.Options@@ -13,7 +14,12 @@ import Agda.Utils.Monad  -- | Check if a type is the 'primSize' type. The argument should be 'reduce'd.-isSizeType :: MonadTCM tcm => Type -> tcm Bool++isSizeType :: Type -> TCM Bool+isSizeType v = isSizeTypeTest <*> pure v++{- ORIGINAL CODE+isSizeType :: Type -> TCM Bool isSizeType (El _ v) = liftTCM $   ifM (not . optSizedTypes <$> pragmaOptions) (return False) $   case v of@@ -22,11 +28,26 @@       return $ x == size     _ -> return False   `catchError` \_ -> return False+-} -sizeType :: MonadTCM tcm => tcm Type+isSizeNameTest :: TCM (QName -> Bool)+isSizeNameTest = liftTCM $+  ifM (not . optSizedTypes <$> pragmaOptions) (return $ const False) $ do+    Def size [] <- primSize+    return (size ==)+  `catchError` \_ -> return $ const False++isSizeTypeTest :: TCM (Type -> Bool)+isSizeTypeTest = do+  testName <- isSizeNameTest+  let testType (El _ (Def d [])) = testName d+      testType _                 = False+  return testType++sizeType :: TCM Type sizeType = El (mkType 0) <$> primSize -sizeSuc :: MonadTCM tcm => tcm (Maybe QName)+sizeSuc :: TCM (Maybe QName) sizeSuc = liftTCM $   ifM (not . optSizedTypes <$> pragmaOptions) (return Nothing) $ do     Def x [] <- primSizeSuc@@ -38,7 +59,7 @@  -- | Compute the size view of a term. The argument should be 'reduce'd. --   Precondition: sized types are enabled.-sizeView :: MonadTCM tcm => Term -> tcm SizeView+sizeView :: Term -> TCM SizeView sizeView v = do   Def inf [] <- primSizeInf   Def suc [] <- primSizeSuc@@ -48,7 +69,7 @@     _                    -> return $ OtherSize v  -- | Turn a size view into a term.-unSizeView :: MonadTCM tcm => SizeView -> tcm Term+unSizeView :: SizeView -> TCM Term unSizeView SizeInf       = primSizeInf unSizeView (SizeSuc v)   = flip apply [Arg NotHidden Relevant v] <$> primSizeSuc unSizeView (OtherSize v) = return v

src/full/Agda/TypeChecking/Monad/State.hs view

@@ -4,6 +4,7 @@ import Control.Applicative import Control.Monad.State import Data.Set (Set)+import Data.Map import qualified Data.Set as Set  import Agda.Syntax.Common@@ -15,30 +16,45 @@  import Agda.Utils.Hash --- | Resets the type checking state. The persistent command line--- options are preserved.+-- | Resets the non-persistent part of the type checking state. -resetState :: MonadTCM tcm => tcm ()-resetState = liftTCM $ do-    opts <- stPersistentOptions <$> get-    put $ initState { stPersistentOptions = opts }+resetState :: TCM ()+resetState = do+    pers <- stPersistent <$> get+    put $ initState { stPersistent = pers } +-- | Resets all of the type checking state.++resetAllState :: TCM ()+resetAllState = put initState+ -- | Set the current scope.-setScope :: MonadTCM tcm => ScopeInfo -> tcm ()-setScope scope = liftTCM $ modify $ \s -> s { stScope = scope }+setScope :: ScopeInfo -> TCM ()+setScope scope = modify $ \s -> s { stScope = scope }  -- | Get the current scope.-getScope :: MonadTCM tcm => tcm ScopeInfo-getScope = liftTCM $ gets stScope+getScope :: TCM ScopeInfo+getScope = gets stScope +-- | Sets stExtLambdaTele .+setExtLambdaTele :: Map QName (Int , Int) -> TCM ()+setExtLambdaTele tele = modify $ \s -> s { stExtLambdaTele = tele }++-- | Get stExtLambdaTele.+getExtLambdaTele :: TCM (Map QName (Int , Int))+getExtLambdaTele = gets stExtLambdaTele++addExtLambdaTele :: QName -> (Int , Int) -> TCM ()+addExtLambdaTele id x = getExtLambdaTele >>= setExtLambdaTele . (insert id x)+ -- | Modify the current scope.-modifyScope :: MonadTCM tcm => (ScopeInfo -> ScopeInfo) -> tcm ()+modifyScope :: (ScopeInfo -> ScopeInfo) -> TCM () modifyScope f = do   s <- getScope   setScope $ f s  -- | Run a computation in a local scope.-withScope :: MonadTCM tcm => ScopeInfo -> tcm a -> tcm (a, ScopeInfo)+withScope :: ScopeInfo -> TCM a -> TCM (a, ScopeInfo) withScope s m = do   s' <- getScope   setScope s@@ -48,11 +64,11 @@   return (x, s'')  -- | Same as 'withScope', but discard the scope from the computation.-withScope_ :: MonadTCM tcm => ScopeInfo -> tcm a -> tcm a+withScope_ :: ScopeInfo -> TCM a -> TCM a withScope_ s m = fst <$> withScope s m  -- | Discard any changes to the scope by a computation.-localScope :: MonadTCM tcm => tcm a -> tcm a+localScope :: TCM a -> TCM a localScope m = do   scope <- getScope   x <- m@@ -61,7 +77,11 @@  -- | Set the top-level module. This affects the global module id of freshly --   generated names.-setTopLevelModule :: MonadTCM tcm => C.QName -> tcm ()++-- TODO: Is the hash-function collision-free? If not, then the+-- implementation of 'setTopLevelModule' should be changed.++setTopLevelModule :: C.QName -> TCM () setTopLevelModule x =   modify $ \s -> s     { stFreshThings = (stFreshThings s)@@ -71,7 +91,7 @@  -- | Use a different top-level module for a computation. Used when generating --   names for imported modules.-withTopLevelModule :: MonadTCM tcm => C.QName -> tcm a -> tcm a+withTopLevelModule :: C.QName -> TCM a -> TCM a withTopLevelModule x m = do   next <- gets $ fName . stFreshThings   setTopLevelModule x@@ -80,10 +100,10 @@   return y  -- | Tell the compiler to import the given Haskell module.-addHaskellImport :: MonadTCM tcm => String -> tcm ()+addHaskellImport :: String -> TCM () addHaskellImport i =   modify $ \s -> s { stHaskellImports = Set.insert i $ stHaskellImports s }  -- | Get the Haskell imports.-getHaskellImports :: MonadTCM tcm => tcm (Set String)+getHaskellImports :: TCM (Set String) getHaskellImports = gets stHaskellImports

src/full/Agda/TypeChecking/Monad/Statistics.hs view

@@ -1,7 +1,6 @@  module Agda.TypeChecking.Monad.Statistics-    ( tick-    , getStatistics+    ( tick, tickN, tickMax, getStatistics     ) where  import Control.Monad.State@@ -10,13 +9,22 @@ import Agda.TypeChecking.Monad.Base  tick :: String -> TCM ()-tick x = modify $ \s ->-  let st' = inc $ stStatistics s in+tick x = tickN x 1++tickN :: String -> Integer -> TCM ()+tickN s n = tick' s (n +)++tick' :: String -> (Integer -> Integer) -> TCM ()+tick' x f = modify $ \s ->+  let st' = upd $ stStatistics s in   force st' `seq` s { stStatistics = st' }   where     -- We need to be strict in the map     force m = sum (Map.elems m)-    inc = Map.insertWith (\_ n -> n + 1) x 1+    upd = Map.insertWith (\_ m -> f m) x (f 0)++tickMax :: String -> Integer -> TCM ()+tickMax s n = tick' s (max n)  getStatistics :: TCM Statistics getStatistics = gets stStatistics

src/full/Agda/TypeChecking/Monad/Trace.hs view

@@ -21,31 +21,35 @@     _			      -> True  -- | Record a function call in the trace.+{-# SPECIALIZE traceCall :: (Maybe r -> Call) -> TCM a -> TCM a #-} traceCall :: MonadTCM tcm => (Maybe r -> Call) -> tcm a -> tcm a traceCall mkCall m = do   let call = mkCall Nothing       r | getRange call /= noRange = const $ getRange call         | otherwise                = id-  cl <- buildClosure call+  cl <- liftTCM $ buildClosure call   let trace | interestingCall cl = local $ \e -> e { envRange = r (envRange e)                                                    , envCall  = Just cl }             | otherwise          = local $ \e -> e { envRange = r (envRange e) }   trace m +{-# SPECIALIZE traceCall_ :: (Maybe () -> Call) -> TCM r -> TCM r #-} traceCall_ :: MonadTCM tcm => (Maybe () -> Call) -> tcm r -> tcm r traceCall_ mkCall = traceCall (mkCall . fmap (const ())) +{-# SPECIALIZE traceCallCPS :: (Maybe r -> Call) -> (r -> TCM a) -> ((r -> TCM a) -> TCM b) -> TCM b #-} traceCallCPS :: MonadTCM tcm => (Maybe r -> Call) -> (r -> tcm a) -> ((r -> tcm a) -> tcm b) -> tcm b traceCallCPS mkCall ret cc = traceCall mkCall (cc ret) +{-# SPECIALIZE traceCallCPS_ :: (Maybe () -> Call) -> TCM a -> (TCM a -> TCM b) -> TCM b #-} traceCallCPS_ :: MonadTCM tcm => (Maybe () -> Call) -> tcm a -> (tcm a -> tcm b) -> tcm b traceCallCPS_ mkCall ret cc =     traceCallCPS mkCall (const ret) (\k -> cc $ k ()) -getCurrentRange :: MonadTCM tcm => tcm Range+getCurrentRange :: TCM Range getCurrentRange = envRange <$> ask -setCurrentRange :: MonadTCM tcm => Range -> tcm a -> tcm a+setCurrentRange :: Range -> TCM a -> TCM a setCurrentRange r   | r == noRange = id   | otherwise    = traceCall (SetRange r)

src/full/Agda/TypeChecking/Patterns/Match.hs view

@@ -41,7 +41,7 @@     -- equivalence to case-trees.     DontKnow m `mappend` _		  = DontKnow m -matchPatterns :: MonadTCM tcm => [Arg Pattern] -> [Arg Term] -> tcm (Match, [Arg Term])+matchPatterns :: [Arg Pattern] -> [Arg Term] -> TCM (Match, [Arg Term]) matchPatterns ps vs = do     reportSDoc "tc.match" 50 $       vcat [ text "matchPatterns"@@ -52,7 +52,7 @@     (ms,vs) <- unzip <$> zipWithM' matchPattern ps vs     return (mconcat ms, vs) -matchPattern :: MonadTCM tcm => Arg Pattern -> Arg Term -> tcm (Match, Arg Term)+matchPattern :: Arg Pattern -> Arg Term -> TCM (Match, Arg Term) matchPattern (Arg h' _  (VarP _)) arg@(Arg _ _ v) = return (Yes [v], arg) matchPattern (Arg _  _  (DotP _)) arg@(Arg _ _ v) = return (Yes [v], arg) matchPattern (Arg h' r' (LitP l)) arg@(Arg h r v) = do@@ -71,7 +71,7 @@           -- something irrelevant will just continue matching against           -- irrelevant stuff 		(m, vs) <- matchPatterns ps $-                  repeat $ Arg NotHidden Irrelevant $ Sort Prop+                  repeat $ Arg NotHidden Irrelevant $ DontCare __IMPOSSIBLE__ 		return (m, Arg h Irrelevant $ Con c vs)  matchPattern (Arg h' r' (ConP c _ ps))     (Arg h r v) =

src/full/Agda/TypeChecking/Patterns/Match.hs-boot view

@@ -7,5 +7,4 @@  data Match = Yes [Term] | No | DontKnow (Maybe MetaId) -matchPatterns :: MonadTCM tcm => [Arg Pattern] -> [Arg Term] -> tcm (Match, [Arg Term])-+matchPatterns :: [Arg Pattern] -> [Arg Term] -> TCM (Match, [Arg Term])

src/full/Agda/TypeChecking/Polarity.hs view

@@ -27,7 +27,7 @@   def <- theDef <$> getConstInfo x   case def of     Axiom{}                                 -> return 0-    Function{ funClauses = c : _ }          -> return $ genericLength (clausePats $ translatedClause c)+    Function{ funClauses = c : _ }          -> return $ genericLength (clausePats c)     Function{ funClauses = [] }             -> return 0     Datatype{ dataPars = np, dataIxs = ni } -> return np     Record{ recPars = n }                   -> return n@@ -136,7 +136,8 @@   polarities i = polarities i . unArg  instance HasPolarity a => HasPolarity (Abs a) where-  polarities i = polarities (i + 1) . absBody+  polarities i (Abs   _ b) = polarities (i + 1) b+  polarities i (NoAbs _ v) = polarities i v  instance HasPolarity a => HasPolarity [a] where   polarities i xs = concat <$> mapM (polarities i) xs@@ -153,13 +154,27 @@               | otherwise -> polarities i ts     Lam _ t    -> polarities i t     Lit _      -> return []+    Level l    -> polarities i l     Def x ts   -> do       pols <- getPolarity x       let compose p ps = map (composePol p) ps       concat . zipWith compose (pols ++ repeat Invariant) <$> mapM (polarities i) ts     Con _ ts   -> polarities i ts     Pi a b     -> (++) <$> (map neg <$> polarities i a) <*> polarities i b-    Fun a b    -> (++) <$> (map neg <$> polarities i a) <*> polarities i b     Sort _     -> return []     MetaV _ ts -> map (const Invariant) <$> polarities i ts-    DontCare   -> return []+    DontCare _ -> return []++instance HasPolarity Level where+  polarities i (Max as) = polarities i as++instance HasPolarity PlusLevel where+  polarities i ClosedLevel{} = return []+  polarities i (Plus _ l) = polarities i l++instance HasPolarity LevelAtom where+  polarities i l = case l of+    MetaLevel _ vs   -> map (const Invariant) <$> polarities i l+    BlockedLevel _ v -> polarities i v+    NeutralLevel v   -> polarities i v+    UnreducedLevel v -> polarities i v

src/full/Agda/TypeChecking/Polarity.hs-boot view

@@ -5,4 +5,3 @@ import Agda.TypeChecking.Monad.Base  computePolarity :: QName -> TCM ()-

src/full/Agda/TypeChecking/Positivity.hs view

@@ -35,6 +35,7 @@   qs <- lookupMutualBlock mi   reportSDoc "tc.pos.tick" 100 $ text "positivity of" <+> prettyTCM (Set.toList qs)   g  <- buildOccurrenceGraph qs+  let gstar = Graph.transitiveClosure $ fmap occ g   reportSDoc "tc.pos.tick" 100 $ text "constructed graph"   reportSLn "tc.pos.graph" 5 $ "Positivity graph: N=" ++ show (size $ Graph.nodes g) ++                                " E=" ++ show (length $ Graph.edges g)@@ -42,7 +43,7 @@     [ text "positivity graph for" <+> prettyTCM (Set.toList qs)     , nest 2 $ prettyGraph g     ]-  mapM_ (setArgs g) $ Set.toList qs+  mapM_ (setArgs gstar) $ Set.toList qs   reportSDoc "tc.pos.tick" 100 $ text "set args"   whenM positivityCheckEnabled $     mapM_ (checkPos g) $ Set.toList qs@@ -60,6 +61,7 @@             [prettyTCM how]           setCurrentRange (getRange q) $ typeError $ GenericError (show err) +    occ (Edge o _) = o     isNegative (Edge o _) = o == Negative      isDatatype q = do@@ -69,25 +71,18 @@         Record  {recClause  = Nothing} -> True         _ -> False -    getArity q = do-      def <- theDef <$> getConstInfo q-      return $ case def of-        Function{ funClauses = c : _ } -> size $ clausePats $ translatedClause c-        Datatype{ dataPars = n }       -> n-        Record{ recPars = n }          -> n-        _                              -> 0-     -- Set the polarity of the arguments to a definition     setArgs g q = do       reportSDoc "tc.pos.args" 5 $ text "checking args of" <+> prettyTCM q-      n <- getArity q+      n <- getDefArity =<< getConstInfo q       let nArgs = maximum $ n :                     [ i + 1 | (ArgNode q1 i) <- Set.toList $ Graph.nodes g                     , q1 == q ]-          findOcc i = case Graph.allPaths isNegative (ArgNode q i) (DefNode q) g of-            []                     -> Unused -- Unused is not good for datatypes (why not? let's do it anyway!)-            es | any isNegative es -> Negative-               | otherwise         -> Positive+          findOcc i = case Graph.lookup (ArgNode q i) (DefNode q) g of+              Nothing -> Unused+              Just Negative -> Negative+              Just Positive -> Positive+              Just Unused   -> Unused           args = map findOcc [0..nArgs - 1]       reportSDoc "tc.pos.args" 10 $ sep         [ text "args of" <+> prettyTCM q <+> text "="@@ -95,6 +90,14 @@         ]       setArgOccurrences q args +getDefArity def = case theDef def of+  Function{ funClauses = cs, funProjection = proj } -> do+    let dropped = maybe 0 (fromIntegral . subtract 1 . snd) proj+    subtract dropped . arity <$> instantiateFull (defType def)+  Datatype{ dataPars = n } -> return n+  Record{ recPars = n }    -> return n+  _                        -> return 0+ -- Specification of occurrences -------------------------------------------  instance SemiRing Occurrence where@@ -229,16 +232,12 @@  instance ComputeOccurrences Clause where   occurrences vars (Clause{ clausePats = ps, clauseBody = body }) =-    -- We don't treat pattern matching as something dangerous-    -- concatOccurs (zipWith match [0..] ps) >+<     walk vars (patItems ps) body     where       walk _    _         NoBody     = Map.empty       walk vars []        (Body v)   = occurrences vars v       walk vars (i : pis) (Bind b)   = walk (i : vars) pis $ absBody b-      walk vars (_ : pis) (NoBind b) = walk vars pis b       walk _    []        Bind{}     = __IMPOSSIBLE__-      walk _    []        NoBind{}   = __IMPOSSIBLE__       walk _    (_ : _)   Body{}     = __IMPOSSIBLE__        match i (Arg _ _ VarP{}) = Map.empty@@ -246,7 +245,9 @@        patItems ps = concat $ zipWith patItem [0..] $ map unArg ps       patItem i (VarP _) = [Just (AnArg i)]-      patItem i p        = replicate (nVars p) (Just (AnArg i)) -- Nothing+      patItem i p        = replicate (nVars p) (Just (AnArg i))+        -- if we're pattern matching it's not something the positivity checker needs to worry about+        -- Actually it is: see issue 464        nVars p = case p of         VarP{}      -> 1@@ -257,7 +258,7 @@ instance ComputeOccurrences Term where   occurrences vars v = case v of     Var i args ->-      maybe Map.empty here (vars ! fromIntegral i)+      maybe Map.empty here (index vars $ fromIntegral i)       >+< occursAs VarArg (occurrences vars args)     Def d args   ->       here (ADef d) >+<@@ -266,19 +267,32 @@     MetaV _ args -> occursAs MetaArg $ occurrences vars args     Pi a b       -> occursAs LeftOfArrow (occurrences vars a) >+<                     occurrences vars b-    Fun a b      -> occursAs LeftOfArrow (occurrences vars a) >+<-                    occurrences vars b     Lam _ b      -> occurrences vars b+    Level l      -> occurrences vars l     Lit{}        -> Map.empty     Sort{}       -> Map.empty-    DontCare     -> Map.empty+    DontCare _   -> Map.empty -- Andreas, 2011-09-09: do we need to check for negative occurrences in irrelevant positions?     where       -- Apparently some development version of GHC chokes if the       -- following line is replaced by vs ! i.-      (!) vs i+      index vs i         | i < length vs = vs !! i-        | otherwise     = error $ show vs ++ " ! " ++ show i ++ "  (" ++ show v ++ ")"+        | otherwise     = __IMPOSSIBLE__ +instance ComputeOccurrences Level where+  occurrences vars (Max as) = occurrences vars as++instance ComputeOccurrences PlusLevel where+  occurrences vars ClosedLevel{} = Map.empty+  occurrences vars (Plus _ l) = occurrences vars l++instance ComputeOccurrences LevelAtom where+  occurrences vars l = case l of+    MetaLevel _ vs   -> occursAs MetaArg $ occurrences vars vs+    BlockedLevel _ v -> occurrences vars v+    NeutralLevel v   -> occurrences vars v+    UnreducedLevel v -> occurrences vars v+ instance ComputeOccurrences Type where   occurrences vars (El _ v) = occurrences vars v @@ -287,7 +301,8 @@   occurrences vars (ExtendTel a b) = occurrences vars (a, b)  instance ComputeOccurrences a => ComputeOccurrences (Abs a) where-  occurrences vars = occurrences (Nothing : vars) . absBody+  occurrences vars (Abs   _ b) = occurrences (Nothing : vars) b+  occurrences vars (NoAbs _ b) = occurrences vars b  instance ComputeOccurrences a => ComputeOccurrences (Arg a) where   occurrences vars = occurrences vars . unArg@@ -304,9 +319,8 @@   def <- getConstInfo q   occursAs (InDefOf q) <$> case theDef def of     Function{funClauses = cs} -> do-      n  <- arity <$> instantiateFull (defType def)-      cs <- map (etaExpandClause n) <$>-              instantiateFull (map translatedClause cs)+      n  <- getDefArity def+      cs <- map (etaExpandClause n) <$> instantiateFull cs       return         $ concatOccurs         $ zipWith (occursAs . InClause) [0..]@@ -350,7 +364,6 @@     vars = reverse [ defaultArg $ Var i [] | i <- [0..m - 1] ]      liftBody m (Bind b)   = Bind $ fmap (liftBody m) b-    liftBody m (NoBind b) = NoBind $ liftBody m b     liftBody m NoBody     = bind m NoBody     liftBody m (Body v)   = bind m $ Body $ raise m v `apply` vars

src/full/Agda/TypeChecking/Pretty.hs view

@@ -1,4 +1,5 @@-{-# LANGUAGE CPP, TypeSynonymInstances, UndecidableInstances #-}+{-# LANGUAGE CPP, TypeSynonymInstances, FlexibleInstances,+             UndecidableInstances #-} module Agda.TypeChecking.Pretty where  import Control.Applicative hiding (empty)@@ -13,6 +14,7 @@ import qualified Agda.Syntax.Concrete.Pretty as P  import Agda.TypeChecking.Monad+import Agda.TypeChecking.Eliminators  import qualified Agda.Utils.Pretty as P import Agda.Utils.Impossible@@ -25,24 +27,28 @@  type Doc = P.Doc -empty, comma :: MonadTCM tcm => tcm Doc+empty, comma :: TCM Doc  empty	   = return P.empty comma	   = return P.comma pretty x   = return $ P.pretty x prettyA x  = P.prettyA x+text :: String -> TCM Doc text s	   = return $ P.text s pwords s   = map return $ P.pwords s fwords s   = return $ P.fwords s+sep, fsep, hsep, vcat :: [TCM Doc] -> TCM Doc sep ds	   = P.sep <$> sequence ds fsep ds    = P.fsep <$> sequence ds hsep ds    = P.hsep <$> sequence ds vcat ds    = P.vcat <$> sequence ds+($$), (<>), (<+>) :: TCM Doc -> TCM Doc -> TCM Doc d1 $$ d2   = (P.$$) <$> d1 <*> d2 d1 <> d2   = (P.<>) <$> d1 <*> d2 d1 <+> d2  = (P.<+>) <$> d1 <*> d2 nest n d   = P.nest n <$> d braces d   = P.braces <$> d+dbraces d  = P.dbraces <$> d brackets d = P.brackets <$> d parens d   = P.parens <$> d @@ -58,7 +64,7 @@ ---------------------------------------------------------------------------  class PrettyTCM a where-    prettyTCM :: MonadTCM tcm => a -> tcm Doc+    prettyTCM :: a -> TCM Doc  instance PrettyTCM a => PrettyTCM (Closure a) where     prettyTCM cl = enterClosure cl prettyTCM@@ -71,6 +77,7 @@ instance PrettyTCM Sort where prettyTCM x = prettyA =<< reify x instance PrettyTCM DisplayTerm where prettyTCM x = prettyA =<< reify x instance PrettyTCM NamedClause where prettyTCM x = prettyA =<< reify x+instance PrettyTCM Level where prettyTCM x = prettyA =<< reify (Level x)  instance PrettyTCM ClauseBody where   prettyTCM b = do@@ -79,16 +86,13 @@     where       walk NoBody = return ([], P.text "()")       walk (Body v) = (,) [] <$> prettyTCM v-      walk (NoBind b) = do-        (bs, v) <- walk b-        return (text "." : bs, v)       walk (Bind b) = do         (bs, v) <- underAbstraction_ b walk         return (text (absName b) : bs, v)  instance (PrettyTCM a, PrettyTCM b) => PrettyTCM (Judgement a b) where   prettyTCM (HasType a t) = prettyTCM a <+> text ":" <+> prettyTCM t-  prettyTCM (IsSort a)    = text "Sort" <+> prettyTCM a+  prettyTCM (IsSort  a t) = text "Sort" <+> prettyTCM a <+> text ":" <+> prettyTCM t  instance PrettyTCM MetaId where   prettyTCM = text . show@@ -100,11 +104,16 @@ instance (Reify a e, ToConcrete e c, P.Pretty c) => PrettyTCM (Arg a) where     prettyTCM x = prettyA =<< reify x +instance PrettyTCM Elim where+  prettyTCM (Apply v) = text "$" <+> prettyTCM v+  prettyTCM (Proj f)  = text "." <> prettyTCM f+ instance PrettyTCM A.Expr where     prettyTCM = prettyA  instance PrettyTCM Relevance where   prettyTCM Irrelevant = text "."+  prettyTCM NonStrict  = text ".."   prettyTCM Relevant   = empty   prettyTCM Forced     = empty @@ -112,6 +121,9 @@   prettyTCM CmpEq  = text "=="   prettyTCM CmpLeq = text "=<" +instance PrettyTCM ProblemConstraint where+  prettyTCM (PConstr pid c) = brackets (text $ show pid) <+> prettyTCM c+ instance PrettyTCM Constraint where     prettyTCM c = case c of 	ValueCmp cmp ty s t ->@@ -120,15 +132,11 @@ 		      ] 		, nest 2 $ text ":" <+> prettyTCM ty 		]-        ArgsCmp cmps t us vs ->-          sep [ prettyList-                [ sep [ prettyTCM u-                      , nest 2 $ text "~~" <+> prettyTCM v-                      , nest 2 $ text (show cmp)-                      ] | (cmp, u, v) <- zip3 cmps us vs-                ]-              , nest 2 $ text ":" <+> prettyTCM t-              ]+        ElimCmp cmps t v us vs ->+          sep [ sep [ prettyTCM us+                    , nest 2 $ text "~~" <+> prettyTCM vs+                    ]+              , text ":" <+> prettyTCM t ] 	LevelCmp cmp a b -> 	    sep [ prettyTCM a 		, prettyTCM cmp <+> prettyTCM b@@ -137,17 +145,17 @@ 	    sep [ prettyTCM a 		, prettyTCM cmp <+> prettyTCM b 		]-	TelCmp cmp a b ->-	    sep [ prettyTCM a-		, prettyTCM cmp <+> prettyTCM b+	TelCmp a b cmp tela telb ->+	    sep [ prettyTCM tela+		, prettyTCM cmp <+> prettyTCM telb 		] 	SortCmp cmp s1 s2 -> 	    sep [ prettyTCM s1 		, prettyTCM cmp <+> prettyTCM s2 		]-	Guarded c cs ->+	Guarded c pid -> 	    sep [ prettyTCM c-		, nest 2 $ brackets $ sep $ punctuate comma $ map prettyTCM cs+		, nest 2 $ brackets $ text "blocked on problem" <+> text (show pid) 		] 	UnBlock m   -> do 	    -- BlockedConst t <- mvInstantiation <$> lookupMeta m@@ -159,13 +167,15 @@                     ]               PostponedTypeCheckingProblem cl -> enterClosure cl $ \(e, a, _) ->                 sep [ text (show m) <+> text ":="-                    , nest 2 $ sep [ prettyA e <+> text ":"+                    , nest 2 $ sep [ prettyA e <+> text ":?"                                    , prettyTCM a                                    ]                     ]               Open{}  -> __IMPOSSIBLE__+              OpenIFS{}  -> __IMPOSSIBLE__               InstS{} -> __IMPOSSIBLE__               InstV{} -> __IMPOSSIBLE__+	FindInScope m   -> sep [ text $ "Find in scope " ++ (show m) ]         IsEmpty t ->             sep [ text "Is empty:", nest 2 $ prettyTCM t ] @@ -201,11 +211,7 @@             where               par NotHidden = P.parens               par Hidden    = P.braces-{--              rel Irrelevant x = P.text "." P.<> x-              rel Relevant x   = x-              rel Forced   x   = x--}+              par Instance  = P.dbraces  instance PrettyTCM Context where   prettyTCM = prettyTCM . PrettyContext

+ src/full/Agda/TypeChecking/Pretty.hs-boot view

@@ -0,0 +1,26 @@+module Agda.TypeChecking.Pretty where++import Agda.Syntax.Common+import Agda.Syntax.Internal+import Agda.Syntax.Literal++import Agda.TypeChecking.Monad+import Agda.Utils.Pretty (Doc)+import qualified Agda.Utils.Pretty as P++text                  :: String             -> TCM Doc+sep, fsep, hsep, vcat :: [TCM Doc]          -> TCM Doc+($$), (<>), (<+>)     :: TCM Doc -> TCM Doc -> TCM Doc++class PrettyTCM a where+    prettyTCM :: a -> TCM Doc++instance PrettyTCM a => PrettyTCM (Closure a) where+instance PrettyTCM a => PrettyTCM [a] where++instance PrettyTCM Name where+instance PrettyTCM QName where+instance PrettyTCM Term where+instance PrettyTCM Type where+instance PrettyTCM Sort where+instance PrettyTCM DisplayTerm where

src/full/Agda/TypeChecking/Primitive.hs view

@@ -12,6 +12,8 @@ import qualified Data.Map as Map import Data.Char +import Agda.Interaction.Options+ import Agda.Syntax.Position import Agda.Syntax.Common hiding (Nat) import Agda.Syntax.Internal@@ -25,9 +27,11 @@ import Agda.TypeChecking.Reduce import Agda.TypeChecking.Substitute import Agda.TypeChecking.Errors+import Agda.TypeChecking.Quote (quoteType, quotingKit) import Agda.TypeChecking.Pretty ()  -- instances only import {-# SOURCE #-} Agda.TypeChecking.Conversion import Agda.TypeChecking.Constraints+import Agda.TypeChecking.Level  import Agda.Utils.Monad import Agda.Utils.Pretty (pretty)@@ -36,17 +40,20 @@ import Agda.Utils.Impossible  -- | Rewrite a literal to constructor form if possible.-constructorForm :: MonadTCM tcm => Term -> tcm Term+constructorForm :: Term -> TCM Term constructorForm v = case v of-    Lit (LitInt r n)   -> cons primZero primSuc (LitInt r) n-    Lit (LitLevel r n) -> cons primLevelZero primLevelSuc (LitLevel r) n-    _                  -> return v+-- Andreas, 2011-10-03, the following line restores IrrelevantLevel+    DontCare v                  -> constructorForm v+    Lit (LitInt r n)            -> cons primZero primSuc (Lit . LitInt r) n+--     Level (Max [])              -> primLevelZero+--     Level (Max [ClosedLevel n]) -> cons primLevelZero primLevelSuc (Level . Max . (:[]) . ClosedLevel) n+    _                           -> return v   where     cons pZero pSuc lit n       | n == 0  = pZero       | n > 0   = do         s <- pSuc-        return $ s `apply` [defaultArg $ Lit $ lit $ n - 1]+        return $ s `apply` [defaultArg $ lit $ n - 1]       | otherwise	= return v  ---------------------------------------------------------------------------@@ -73,7 +80,7 @@     show = show . unNat  class PrimType a where-    primType :: MonadTCM tcm => a -> tcm Type+    primType :: a -> TCM Type  instance (PrimType a, PrimType b) => PrimTerm (a -> b) where     primTerm _ = unEl <$> (primType (undefined :: a) --> primType (undefined :: b))@@ -81,7 +88,7 @@ instance PrimTerm a => PrimType a where     primType _ = el $ primTerm (undefined :: a) -class	 PrimTerm a	  where primTerm :: MonadTCM tcm => a -> tcm Term+class	 PrimTerm a	  where primTerm :: a -> TCM Term instance PrimTerm Integer where primTerm _ = primInteger instance PrimTerm Bool	  where primTerm _ = primBool instance PrimTerm Char	  where primTerm _ = primChar@@ -90,6 +97,7 @@ instance PrimTerm Nat	  where primTerm _ = primNat instance PrimTerm Lvl     where primTerm _ = primLevel instance PrimTerm QName   where primTerm _ = primQName+instance PrimTerm Type    where primTerm _ = primAgdaType  instance PrimTerm a => PrimTerm [a] where     primTerm _ = list (primTerm (undefined :: a))@@ -100,11 +108,11 @@ -- From Agda term to Haskell value  class ToTerm a where-    toTerm :: MonadTCM tcm => tcm (a -> Term)+    toTerm :: TCM (a -> Term)  instance ToTerm Integer where toTerm = return $ Lit . LitInt noRange instance ToTerm Nat	where toTerm = return $ Lit . LitInt noRange . unNat-instance ToTerm Lvl	where toTerm = return $ Lit . LitLevel noRange . unLvl+instance ToTerm Lvl	where toTerm = return $ Level . Max . (:[]) . ClosedLevel . unLvl instance ToTerm Double  where toTerm = return $ Lit . LitFloat noRange instance ToTerm Char	where toTerm = return $ Lit . LitChar noRange instance ToTerm Str	where toTerm = return $ Lit . LitString noRange . unStr@@ -116,9 +124,12 @@ 	false <- primFalse 	return $ \b -> if b then true else false +instance ToTerm Type where+    toTerm = snd <$> quotingKit+ -- | @buildList A ts@ builds a list of type @List A@. Assumes that the terms --   @ts@ all have type @A@.-buildList :: MonadTCM tcm => tcm ([Term] -> Term)+buildList :: TCM ([Term] -> Term) buildList = do     nil'  <- primNil     cons' <- primCons@@ -137,7 +148,7 @@ type FromTermFunction a = Arg Term -> TCM (Reduced (MaybeReduced (Arg Term)) a)  class FromTerm a where-    fromTerm :: MonadTCM tcm => tcm (FromTermFunction a)+    fromTerm :: TCM (FromTermFunction a)  instance FromTerm Integer where     fromTerm = fromLiteral $ \l -> case l of@@ -150,9 +161,9 @@ 	_	   -> Nothing  instance FromTerm Lvl where-    fromTerm = fromLiteral $ \l -> case l of-	LitLevel _ n -> Just $ Lvl n-	_	     -> Nothing+    fromTerm = fromReducedTerm $ \l -> case l of+	Level (Max [ClosedLevel n]) -> Just $ Lvl n+	_                           -> Nothing  instance FromTerm Double where     fromTerm = fromLiteral $ \l -> case l of@@ -223,47 +234,121 @@           _ -> return $ NoReduction (reduced b)  -- | Conceptually: @redBind m f k = either (return . Left . f) k =<< m@-redBind :: MonadTCM tcm => tcm (Reduced a a') -> (a -> b) ->-	     (a' -> tcm (Reduced b b')) -> tcm (Reduced b b')+redBind :: TCM (Reduced a a') -> (a -> b) ->+	     (a' -> TCM (Reduced b b')) -> TCM (Reduced b b') redBind ma f k = do     r <- ma     case r of 	NoReduction x	-> return $ NoReduction $ f x 	YesReduction y	-> k y -redReturn :: MonadTCM tcm => a -> tcm (Reduced a' a)+redReturn :: a -> TCM (Reduced a' a) redReturn = return . YesReduction -fromReducedTerm :: MonadTCM tcm => (Term -> Maybe a) -> tcm (FromTermFunction a)+fromReducedTerm :: (Term -> Maybe a) -> TCM (FromTermFunction a) fromReducedTerm f = return $ \t -> do     b <- reduceB t     case f $ unArg (ignoreBlocking b) of 	Just x	-> return $ YesReduction x 	Nothing	-> return $ NoReduction (reduced b) -fromLiteral :: MonadTCM tcm => (Literal -> Maybe a) -> tcm (FromTermFunction a)+fromLiteral :: (Literal -> Maybe a) -> TCM (FromTermFunction a) fromLiteral f = fromReducedTerm $ \t -> case t of     Lit lit -> f lit     _	    -> Nothing --- trustMe : {A : Set}{a b : A} -> a ≡ b-primTrustMe :: MonadTCM tcm => tcm PrimitiveImpl+-- trustMe : {a : Level} {A : Set a} {x y : A} -> x ≡ y+primTrustMe :: TCM PrimitiveImpl primTrustMe = do-  refl <- primRefl-  t    <- hPi "A" tset $ hPi "a" (el $ var 0) $ hPi "b" (el $ var 1) $-          el (primEquality <#> var 2 <@> var 1 <@> var 0)-  return $ PrimImpl t $ PrimFun __IMPOSSIBLE__ 3 $ \ts ->+  clo <- commandLineOptions+  when (optSafe clo) (typeError SafeFlagPrimTrustMe)+  t    <- hPi "a" (el primLevel) $+          hPi "A" (return $ sort $ varSort 0) $+          hPi "x" (El (varSort 1) <$> var 0) $+          hPi "y" (El (varSort 2) <$> var 1) $+          El (varSort 3) <$>+            primEquality <#> var 3 <#> var 2 <@> var 1 <@> var 0+  Con rf [] <- primRefl+  n         <- conPars . theDef <$> getConstInfo rf+  let refl x | n == 2    = Con rf [Arg Hidden Forced x]+             | n == 3    = Con rf []+             | otherwise = __IMPOSSIBLE__+  return $ PrimImpl t $ PrimFun __IMPOSSIBLE__ 4 $ \ts ->       case ts of-        [t, a, b] -> liftTCM $ do-              noConstraints $ equalTerm (El (mkType 0) $ unArg t) (unArg a) (unArg b)-              rf <- return refl -- <#> return (unArg t) <#> return (unArg a)-              redReturn rf-            `catchError` \_ -> return (NoReduction $ map notReduced [t, a, b])+        [a, t, x, y] -> liftTCM $ do+              noConstraints $+                equalTerm (El (Type $ lvlView $ unArg a) (unArg t))+                          (unArg x) (unArg y)+              redReturn (refl $ unArg x)+            `catchError` \_ -> return (NoReduction $ map notReduced [a, t, x, y])         _ -> __IMPOSSIBLE__ +primQNameType :: TCM PrimitiveImpl+primQNameType = mkPrimFun1TCM (el primQName --> el primAgdaType) typeOfConst++primQNameDefinition :: TCM PrimitiveImpl+primQNameDefinition = do+  let argQName qn = [defaultArg (Lit (LitQName noRange qn))]+      app mt xs = do t <- mt+                     return $ apply t xs++      con qn Function{}    = app primAgdaDefinitionFunDef    (argQName qn)+      con qn Datatype{}    = app primAgdaDefinitionDataDef   (argQName qn)+      con qn Record{}      = app primAgdaDefinitionRecordDef (argQName qn)+      con _  Axiom{}       = app primAgdaDefinitionPostulate []+      con _  Primitive{}   = app primAgdaDefinitionPrimitive []+      con _  Constructor{} = app primAgdaDefinitionDataConstructor []++  unquoteQName <- fromTerm+  t <- el primQName --> el primAgdaDefinition+  return $ PrimImpl t $ PrimFun __IMPOSSIBLE__ 1 $ \ts ->+    case ts of+      [v] -> liftTCM $+        redBind (unquoteQName v)+            (\v' -> [v']) $ \x ->+        redReturn =<< con x . theDef =<< getConstInfo x+      _ -> __IMPOSSIBLE__++primDataConstructors :: TCM PrimitiveImpl+primDataConstructors = mkPrimFun1TCM (el primAgdaDataDef --> el (list primQName))+                                     (fmap (dataCons . theDef) . getConstInfo)++mkPrimLevelZero :: TCM PrimitiveImpl+mkPrimLevelZero = do+  t <- primType (undefined :: Lvl)+  return $ PrimImpl t $ PrimFun __IMPOSSIBLE__ 0 $ \_ -> redReturn $ Level $ Max []++mkPrimLevelSuc :: TCM PrimitiveImpl+mkPrimLevelSuc = do+  t <- primType (id :: Lvl -> Lvl)+  return $ PrimImpl t $ PrimFun __IMPOSSIBLE__ 1 $ \ ~[a] -> liftTCM $ do+    l <- levelView $ unArg a+    redReturn $ Level $ levelSuc l++mkPrimLevelMax :: TCM PrimitiveImpl+mkPrimLevelMax = do+  t <- primType (max :: Op Lvl)+  return $ PrimImpl t $ PrimFun __IMPOSSIBLE__ 2 $ \ ~[a, b] -> liftTCM $ do+    Max as <- levelView $ unArg a+    Max bs <- levelView $ unArg b+    redReturn $ Level $ levelMax $ as ++ bs++mkPrimFun1TCM :: (FromTerm a, ToTerm b) => TCM Type -> (a -> TCM b) -> TCM PrimitiveImpl+mkPrimFun1TCM mt f = do+    toA   <- fromTerm+    fromB <- toTerm+    t     <- mt+    return $ PrimImpl t $ PrimFun __IMPOSSIBLE__ 1 $ \ts ->+      case ts of+        [v] -> liftTCM $+          redBind (toA v)+              (\v' -> [v']) $ \x ->+          redReturn . fromB =<< f x+        _ -> __IMPOSSIBLE__+ -- Tying the knot-mkPrimFun1 :: (MonadTCM tcm, PrimType a, PrimType b, FromTerm a, ToTerm b) =>-	      (a -> b) -> tcm PrimitiveImpl+mkPrimFun1 :: (PrimType a, PrimType b, FromTerm a, ToTerm b) =>+	      (a -> b) -> TCM PrimitiveImpl mkPrimFun1 f = do     toA   <- fromTerm     fromB <- toTerm@@ -276,8 +361,8 @@           redReturn $ fromB $ f x         _ -> __IMPOSSIBLE__ -mkPrimFun2 :: (MonadTCM tcm, PrimType a, PrimType b, PrimType c, FromTerm a, ToTerm a, FromTerm b, ToTerm c) =>-	      (a -> b -> c) -> tcm PrimitiveImpl+mkPrimFun2 :: (PrimType a, PrimType b, PrimType c, FromTerm a, ToTerm a, FromTerm b, ToTerm c) =>+	      (a -> b -> c) -> TCM PrimitiveImpl mkPrimFun2 f = do     toA   <- fromTerm     fromA <- toTerm@@ -295,13 +380,12 @@           redReturn $ fromC $ f x y         _ -> __IMPOSSIBLE__ -mkPrimFun4 :: ( MonadTCM tcm-              , PrimType a, FromTerm a, ToTerm a+mkPrimFun4 :: ( PrimType a, FromTerm a, ToTerm a               , PrimType b, FromTerm b, ToTerm b               , PrimType c, FromTerm c, ToTerm c               , PrimType d, FromTerm d               , PrimType e, ToTerm e) =>-	      (a -> b -> c -> d -> e) -> tcm PrimitiveImpl+	      (a -> b -> c -> d -> e) -> TCM PrimitiveImpl mkPrimFun4 f = do     (toA, fromA) <- (,) <$> fromTerm <*> toTerm     (toB, fromB) <- (,) <$> fromTerm <*> toTerm@@ -334,48 +418,49 @@ -- Type combinators infixr 4 --> -(-->) :: MonadTCM tcm => tcm Type -> tcm Type -> tcm Type+(-->) :: TCM Type -> TCM Type -> TCM Type a --> b = do     a' <- a     b' <- b-    return $ El (getSort a' `sLub` getSort b') $ Fun (defaultArg a') b'+    return $ El (getSort a' `sLub` getSort b') $ Pi (defaultArg a') (NoAbs "_" b') -gpi :: MonadTCM tcm => Hiding -> Relevance -> String -> tcm Type -> tcm Type -> tcm Type+gpi :: Hiding -> Relevance -> String -> TCM Type -> TCM Type -> TCM Type gpi h r name a b = do-    a' <- a-    x  <- freshName_ name-    b' <- addCtx x (Arg h r a') b-    return $ El (getSort a' `sLub` getSort b') $ Pi (Arg h r a') (Abs name b')+  a <- a+  x <- freshName_ name+  b <- addCtx x (Arg h r a) b+  return $ El (getSort a `dLub` Abs name (getSort b))+              (Pi (Arg h r a) (Abs name b)) -hPi, nPi :: MonadTCM tcm => String -> tcm Type -> tcm Type -> tcm Type+hPi, nPi :: String -> TCM Type -> TCM Type -> TCM Type hPi = gpi Hidden Relevant nPi = gpi NotHidden Relevant -var :: MonadTCM tcm => Integer -> tcm Term+var :: Integer -> TCM Term var n = return $ Var n []  infixl 9 <@>, <#> -gApply :: MonadTCM tcm => Hiding -> tcm Term -> tcm Term -> tcm Term+gApply :: Hiding -> TCM Term -> TCM Term -> TCM Term gApply h a b = do     x <- a     y <- b     return $ x `apply` [Arg h Relevant y] -(<@>),(<#>) :: MonadTCM tcm => tcm Term -> tcm Term -> tcm Term+(<@>),(<#>) :: TCM Term -> TCM Term -> TCM Term (<@>) = gApply NotHidden (<#>) = gApply Hidden -list :: MonadTCM tcm => tcm Term -> tcm Term+list :: TCM Term -> TCM Term list t = primList <@> t -io :: MonadTCM tcm => tcm Term -> tcm Term+io :: TCM Term -> TCM Term io t = primIO <@> t -el :: MonadTCM tcm => tcm Term -> tcm Type+el :: TCM Term -> TCM Type el t = El (mkType 0) <$> t -tset :: MonadTCM tcm => tcm Type+tset :: TCM Type tset = return $ sort (mkType 0)  -- | Abbreviation: @argN = 'Arg' 'NotHidden' 'Relevant'@.@@ -422,7 +507,9 @@         in mkPrimFun4 aux     , "primNatEquality"	    |-> mkPrimFun2 ((==)		    :: Rel Nat)     , "primNatLess"	    |-> mkPrimFun2 ((<)			    :: Rel Nat)-    , "primLevelMax"	    |-> mkPrimFun2 (max			    :: Op Lvl)+    , "primLevelZero"	    |-> mkPrimLevelZero+    , "primLevelSuc"	    |-> mkPrimLevelSuc+    , "primLevelMax"	    |-> mkPrimLevelMax      -- Floating point functions     , "primIntegerToFloat"  |-> mkPrimFun1 (fromIntegral :: Integer -> Double)@@ -462,6 +549,11 @@     , "primStringEquality"  |-> mkPrimFun2 ((==) :: Rel Str)     , "primShowString"	    |-> mkPrimFun1 (Str . show . pretty . LitString noRange . unStr) +    -- Reflection+    , "primQNameType"       |-> primQNameType+    , "primQNameDefinition" |-> primQNameDefinition+    , "primDataConstructors"|-> primDataConstructors+     -- Other stuff     , "primTrustMe"         |-> primTrustMe     , "primQNameEquality"  |-> mkPrimFun2 ((==) :: Rel QName)@@ -469,7 +561,7 @@     where 	(|->) = (,) -lookupPrimitiveFunction :: MonadTCM tcm => String -> tcm PrimitiveImpl+lookupPrimitiveFunction :: String -> TCM PrimitiveImpl lookupPrimitiveFunction x =     case Map.lookup x primitiveFunctions of 	Just p	-> liftTCM p@@ -477,7 +569,7 @@  -- | Rebind a primitive. Assumes everything is type correct. Used when --   importing a module with primitives.-rebindPrimitive :: MonadTCM tcm => String -> tcm PrimFun+rebindPrimitive :: String -> TCM PrimFun rebindPrimitive x = do     PrimImpl _ pf <- lookupPrimitiveFunction x     bindPrimitive x pf

src/full/Agda/TypeChecking/Quote.hs view

@@ -1,3 +1,4 @@+{-# LANGUAGE CPP #-}  module Agda.TypeChecking.Quote where @@ -10,13 +11,20 @@  import Agda.TypeChecking.Monad import Agda.TypeChecking.Monad.Builtin+import Agda.TypeChecking.Reduce import Agda.TypeChecking.Pretty import Agda.TypeChecking.Substitute -quoteTerm :: Term -> TCM Term-quoteTerm v = do-  false <- primFalse-  true <- primTrue+#include "../undefined.h"+import Agda.Utils.Impossible++quotingKit :: TCM ((Term -> Term), (Type -> Term))+quotingKit = do+  hidden <- primHidden+  instanceH <- primInstance+  visible <- primVisible+  relevant <- primRelevant+  irrelevant <- primIrrelevant   nil <- primNil   cons <- primCons   arg <- primArgArg@@ -26,39 +34,215 @@   con <- primAgdaTermCon   pi <- primAgdaTermPi   sort <- primAgdaTermSort+  set <- primAgdaSortSet+  setLit <- primAgdaSortLit+  unsupportedSort <- primAgdaSortUnsupported+  sucLevel <- primLevelSuc+  lub <- primLevelMax+  el <- primAgdaTypeEl   Con z _ <- primZero   Con s _ <- primSuc   unsupported <- primAgdaTermUnsupported   let t @@ u = apply t [defaultArg u]-      quoteHiding Hidden = true-      quoteHiding NotHidden = false+      quoteHiding Hidden    = hidden+      quoteHiding Instance  = instanceH+      quoteHiding NotHidden = visible+      quoteRelevance Relevant   = relevant+      quoteRelevance Irrelevant = irrelevant+      quoteRelevance NonStrict  = relevant+      quoteRelevance Forced     = relevant+      quoteLit (LitInt   _ n)   = iterate suc zero !! fromIntegral n+      quoteLit _                = unsupported+      -- We keep no ranges in the quoted term, so the equality on terms+      -- is only on the structure.+      quoteSortLevelTerm (Max [])              = setLit @@ Lit (LitInt noRange 0)+      quoteSortLevelTerm (Max [ClosedLevel n]) = setLit @@ Lit (LitInt noRange n)+      quoteSortLevelTerm (Max [Plus 0 (NeutralLevel v)]) = set @@ quote v+      quoteSortLevelTerm _                     = unsupported+      quoteSort (Type t)    = quoteSortLevelTerm t+      quoteSort Prop        = unsupportedSort+      quoteSort Inf         = unsupportedSort+      quoteSort DLub{}      = unsupportedSort+      quoteType (El s t) = el @@ quoteSort s @@ quote t       list [] = nil       list (a : as) = cons @@ a @@ list as       zero = con @@ quoteName z @@ nil-      suc n = con @@ quoteName s @@ list [n]-      quoteArg (Arg h r t) = arg @@ quoteHiding h @@ quote t-      quoteArgs ts = list (map quoteArg ts)+      suc n = con @@ quoteName s @@ list [arg @@ visible @@ relevant @@ n]+      quoteArg q (Arg h r t) = arg @@ quoteHiding h @@ quoteRelevance r @@ q t+      quoteArgs ts = list (map (quoteArg quote) ts)       quote (Var n ts) = var @@ Lit (LitInt noRange n) @@ quoteArgs ts       quote (Lam h t) = lam @@ quoteHiding h @@ quote (absBody t)       quote (Def x ts) = def @@ quoteName x @@ quoteArgs ts       quote (Con x ts) = con @@ quoteName x @@ quoteArgs ts-      quote (Pi t u) = pi @@ quoteArg (fmap unEl t)-                          @@ quote (unEl (absBody u))-      quote (Fun t u) = pi @@ quoteArg (fmap unEl t)-                           @@ quote (raise 1 (unEl u))-      quote (Lit (LitInt _ n)) = iterate suc zero !! fromIntegral n-      quote (Sort _) = sort-      quote _ = unsupported-  return (quote v)+      quote (Pi t u) = pi @@ quoteArg quoteType t+                          @@ quoteType (absBody u)+      quote (Level _) = unsupported+      quote (Lit lit) = quoteLit lit+      quote (Sort s)  = sort @@ quoteSort s+      quote MetaV{}   = unsupported+      quote DontCare{} = unsupported -- could be exposed at some point but we have to take care+  return (quote, quoteType)  quoteName :: QName -> Term quoteName x = Lit (LitQName noRange x) +quoteTerm :: Term -> TCM Term+quoteTerm v = ($v) . fst <$> quotingKit+ quoteType :: Type -> TCM Term-quoteType (El _ v) = quoteTerm v+quoteType v = ($v) . snd <$> quotingKit  agdaTermType :: TCM Type agdaTermType = El (mkType 0) <$> primAgdaTerm  qNameType :: TCM Type qNameType = El (mkType 0) <$> primQName++isCon :: QName -> TCM Term -> TCM Bool+isCon con tm = do t <- tm+                  case t of+                    Con con' _ -> return (con == con')+                    _ -> return False++unquoteFailedGeneric :: String -> TCM a+unquoteFailedGeneric msg = typeError . GenericError $ "Unable to unquote the " ++ msg++unquoteFailed :: String -> String -> Term -> TCM a+unquoteFailed kind msg t = do doc <- prettyTCM t+                              unquoteFailedGeneric $ "term (" ++ show doc ++ ") of type " ++ kind ++ ".\nReason: " ++ msg ++ "."++class Unquote a where+  unquote :: Term -> TCM a++unquoteH :: Unquote a => Arg Term -> TCM a+unquoteH (Arg Hidden Relevant x) = unquote x+unquoteH _                       = unquoteFailedGeneric "argument. It should be `hidden'."++unquoteN :: Unquote a => Arg Term -> TCM a+unquoteN (Arg NotHidden Relevant x) = unquote x+unquoteN _                          = unquoteFailedGeneric "argument. It should be `visible'"++choice :: Monad m => [(m Bool, m a)] -> m a -> m a+choice [] dflt = dflt+choice ((mb, mx) : mxs) dflt = do b <- mb+                                  if b then mx else choice mxs dflt++instance Unquote a => Unquote (Arg a) where+  unquote t = do+    t <- reduce t+    case t of+      Con c [hid,rel,x] -> do+        choice+          [(c `isCon` primArgArg, Arg <$> unquoteN hid <*> unquoteN rel <*> unquoteN x)]+          (unquoteFailed "Arg" "arity 3 and not the `arg' constructor" t)+      _ -> unquoteFailed "Arg" "not of arity 3" t++instance Unquote Integer where+  unquote t = do+    t <- reduce t+    case t of+      Lit (LitInt _ n) -> return n+      _ -> unquoteFailed "Integer" "not a literal integer" t++instance Unquote a => Unquote [a] where+  unquote t = do+    t <- reduce t+    case t of+      Con c [x,xs] -> do+        choice+          [(c `isCon` primCons, (:) <$> unquoteN x <*> unquoteN xs)]+          (unquoteFailed "List" "arity 2 and not the `∷' constructor" t)+      Con c [] -> do+        choice+          [(c `isCon` primNil, return [])]+          (unquoteFailed "List" "arity 0 and not the `[]' constructor" t)+      _ -> unquoteFailed "List" "neither `[]' nor `∷'" t++instance Unquote Hiding where+  unquote t = do+    t <- reduce t+    case t of+      Con c [] -> do+        choice+          [(c `isCon` primHidden,  return Hidden)+          ,(c `isCon` primInstance, return Instance)+          ,(c `isCon` primVisible, return NotHidden)]+          (unquoteFailed "Hiding" "neither `hidden' nor `visible'" t)+      _ -> unquoteFailed "Hiding" "arity is not 0" t++instance Unquote Relevance where+  unquote t = do+    t <- reduce t+    case t of+      Con c [] -> do+        choice+          [(c `isCon` primRelevant,   return Relevant)+          ,(c `isCon` primIrrelevant, return Irrelevant)]+          (unquoteFailed "Relevance" "neither `relevant' or `irrelevant'" t)+      _ -> unquoteFailed "Relevance" "arity is not 0" t++instance Unquote QName where+  unquote t = do+    t <- reduce t+    case t of+      Lit (LitQName _ x) -> return x+      _                  -> unquoteFailed "QName" "not a literal qname value" t++instance Unquote a => Unquote (Abs a) where+  unquote t = do x <- freshNoName_+                 Abs (show x) <$> unquote t++instance Unquote Sort where+  unquote t = do+    t <- reduce t+    case t of+      Con c [] -> do+        choice+          [(c `isCon` primAgdaSortUnsupported, unquoteFailed "Sort" "unsupported sort" t)]+          (unquoteFailed "Sort" "arity 0 and not the `unsupported' constructor" t)+      Con c [u] -> do+        choice+          [(c `isCon` primAgdaSortSet, Type <$> unquoteN u)+          ,(c `isCon` primAgdaSortLit, Type . levelMax . (:[]) . ClosedLevel <$> unquoteN u)]+          (unquoteFailed "Sort" "arity 1 and not the `set' or the `lit' constructors" t)+      _ -> unquoteFailed "Sort" "not of arity 0 nor 1" t++instance Unquote Level where+  unquote l = Max . (:[]) . Plus 0 . UnreducedLevel <$> unquote l++instance Unquote Type where+  unquote t = do+    t <- reduce t+    case t of+      Con c [s, u] -> do+        choice+          [(c `isCon` primAgdaTypeEl, El <$> unquoteN s <*> unquoteN u)]+          (unquoteFailed "Type" "arity 2 and not the `el' constructor" t)+      _ -> unquoteFailed "Type" "not of arity 2" t++instance Unquote Term where+  unquote t = do+    t <- reduce t+    case t of+      Con c [] ->+        choice+          [(c `isCon` primAgdaTermUnsupported, unquoteFailed "Term" "unsupported term" t)]+          (unquoteFailed "Term" "arity 0 and not the `unsupported' constructor" t)++      Con c [x] -> do+        choice+          [(c `isCon` primAgdaTermSort, Sort <$> unquoteN x)]+          (unquoteFailed "Term" "arity 1 and not the `sort' constructor" t)++      Con c [x,y] ->+        choice+          [(c `isCon` primAgdaTermVar, Var <$> unquoteN x <*> unquoteN y)+          ,(c `isCon` primAgdaTermCon, Con <$> unquoteN x <*> unquoteN y)+          ,(c `isCon` primAgdaTermDef, Def <$> unquoteN x <*> unquoteN y)+          ,(c `isCon` primAgdaTermLam, Lam <$> unquoteN x <*> unquoteN y)+          ,(c `isCon` primAgdaTermPi,  Pi  <$> unquoteN x <*> unquoteN y)]+          (unquoteFailed "Term" "arity 2 and none of Var, Con, Def, Lam, Pi" t)++      Con{} -> unquoteFailed "Term" "neither arity 0 nor 1 nor 2" t+      Lit{} -> unquoteFailed "Term" "unexpected literal" t+      _ -> unquoteFailed "Term" "not a constructor" t

src/full/Agda/TypeChecking/Rebind.hs view

@@ -13,18 +13,5 @@  -- | Change 'Bind's to 'NoBind' if the variable is not used in the body. --   Also normalises the body in the process. Or not. Disabled.-rebindClause :: Clauses -> TCM Clauses+rebindClause :: Clause -> TCM Clause rebindClause = return-{--rebindClause (Clause tel perm ps rec b) = return $ Clause tel perm ps rec b-  do-    b <- instantiateFull b-    return $ Clause ps $ rebind b-    where-	rebind (Body t) = Body t-	rebind (Bind b)-	    | 0 `freeIn` absBody b  = Bind $ fmap rebind b-	    | otherwise		    = NoBind $ b `absApp` __IMPOSSIBLE__-	rebind (NoBind b) = NoBind $ rebind b-	rebind  NoBody	  = NoBody--}

src/full/Agda/TypeChecking/RecordPatterns.hs view

@@ -19,7 +19,7 @@ import Agda.TypeChecking.Monad import Agda.TypeChecking.Pretty import Agda.TypeChecking.Reduce-import Agda.TypeChecking.Substitute hiding (Subst)+import Agda.TypeChecking.Substitute import Agda.TypeChecking.Telescope import Agda.Utils.Either import Agda.Utils.List@@ -33,17 +33,23 @@ -- projection functions. Does not remove record constructor patterns -- which have sub-patterns containing non-record constructor or -- literal patterns.+--+-- If the input clause contains dot patterns inside record patterns,+-- then the translation may yield clauses which are not type-correct.+-- However, we believe that it is safe to use the output as input to+-- 'Agda.TypeChecking.CompiledClause.Compile.compileClauses'. Perhaps+-- it would be better to perform record pattern translation on the+-- compiled clauses instead, but the code below has already been+-- implemented and seems to work. -translateRecordPatterns :: MonadTCM tcm => Clause -> tcm Clauses+translateRecordPatterns :: Clause -> TCM Clause translateRecordPatterns clause = do   -- ps: New patterns, in left-to-right order, in the context of the   -- old RHS.    -- s: Partial substitution taking the old pattern variables   -- (including dot patterns; listed from left to right) to terms in-  -- the context of the new RHS. The terms are functions expecting a-  -- substitution taking things in the old telescope's context to the-  -- context of the new RHS.+  -- the context of the new RHS.    -- cs: List of changes, with types in the context of the old   -- telescope.@@ -53,15 +59,20 @@   let -- Number of variables + dot patterns in new clause.       noNewPatternVars = size cs +      s'   = reverse s+      rest = [ Var i [] | i <- [noNewPatternVars..] ]+       -- Substitution used to convert terms in the old RHS's       -- context to terms in the new RHS's context.-      rhsSubst = map (\t -> t rhsSubst') (reverse s) ++-                 [ Var i [] | i <- [noNewPatternVars..] ]+      rhsSubst = s' ++ rest        -- Substitution used to convert terms in the old telescope's       -- context to terms in the new RHS's context.-      rhsSubst' = permute (reverseP $ clausePerm clause) init ++ rest-        where (init, rest) = genericSplitAt (size s) rhsSubst+      rhsSubst' = permute (reverseP $ clausePerm clause) s' ++ rest+      -- TODO: Is it OK to replace the definition above with the+      -- following one?+      --+      --   rhsSubst' = permute (clausePerm clause) s ++ rest        -- The old telescope, flattened and in textual left-to-right       -- order (i.e. the type signature for the variable which occurs@@ -83,7 +94,7 @@       -- Permutation taking the new variable and dot patterns to the       -- new telescope.       newPerm = adjustForDotPatterns $-                  reorderTel $ map (maybe dummy snd) newTel'+                  reorderTel_ $ map (maybe dummy snd) newTel'         where         -- It is important that dummy does not mention any variable         -- (see the definition of reorderTel).@@ -132,10 +143,7 @@         ]       ] -  return $ Clauses { translatedClause    = c-                   , maybeOriginalClause =-                       if all isLeft cs then Nothing else Just clause-                   }+  return c  ------------------------------------------------------------------------ -- Record pattern monad@@ -154,8 +162,8 @@  -- | Runs a computation in the 'RecPatM' monad. -runRecPatM :: MonadTCM tcm => RecPatM a -> tcm a-runRecPatM (RecPatM m) = liftTCM $+runRecPatM :: RecPatM a -> TCM a+runRecPatM (RecPatM m) =   mapTCMT (\m -> do              (x, noVars) <- mfix $ \ ~(_, noVars) ->                               runStateT (runReaderT m noVars) 0@@ -180,14 +188,6 @@ data Kind = VarPat | DotPat   deriving Eq --- | Substitutions (with a twist).------ Some parts of the terms building up the substitution need to have a--- substitution applied to them (in fact, a variant of the--- substitution itself), so a functional representation is used.--type Subst = [Substitution -> Term]- -- | @'Left' p@ means that a variable (corresponding to the pattern -- @p@, a variable or dot pattern) should be kept unchanged. @'Right' -- (n, x, t)@ means that @n 'VarPat'@ variables, and @n 'DotPat'@ dot@@ -202,59 +202,44 @@   = Leaf Pattern     -- ^ Corresponds to variable and dot patterns; contains the     -- original pattern.-  | RecCon (Arg Type) [(Substitution -> Term -> Term, RecordTree)]+  | RecCon (Arg Type) [(Term -> Term, RecordTree)]     -- ^ @RecCon t args@ stands for a record constructor application:     -- @t@ is the type of the application, and the list contains a-    -- projection function (parametrised on a substitution) and a tree-    -- for every argument.+    -- projection function and a tree for every argument.  ------------------------------------------------------------------------ -- Record pattern trees --- | @projections t@ returns a projection (parametrised on a--- substitution) for every non-dot leaf pattern in @t@. The term is--- the composition of the projection functions from the leaf to the--- root. The substitution is used to build the individual projection--- functions.+-- | @projections t@ returns a projection for every non-dot leaf+-- pattern in @t@. The term is the composition of the projection+-- functions from the leaf to the root. -- -- Every term is tagged with its origin: a variable pattern or a dot -- pattern. -projections :: RecordTree -> [(Substitution -> Term -> Term, Kind)]-projections (Leaf (DotP{})) = [(flip const, DotPat)]-projections (Leaf (VarP{})) = [(flip const, VarPat)]+projections :: RecordTree -> [(Term -> Term, Kind)]+projections (Leaf (DotP{})) = [(id, DotPat)]+projections (Leaf (VarP{})) = [(id, VarPat)] projections (Leaf _)        = __IMPOSSIBLE__ projections (RecCon _ args) =-  concatMap (\(p, t) -> map (\(t, k) -> (\s -> t s . p s, k))+  concatMap (\(p, t) -> map (\(p', k) -> (p' . p, k))                             (projections t))             args  -- | Converts a record tree to a single pattern along with information -- about the deleted pattern variables.------ Raises an error if the tree contains dot patterns inside record--- patterns. -removeTree :: RecordTree -> RecPatM (Pattern, Subst, Changes)+removeTree :: RecordTree -> RecPatM (Pattern, Substitution, Changes) removeTree tree = do   (pat, x) <- nextVar   let ps = projections tree-      s  = map (\(p, _) -> \s -> p s x) ps+      s  = map (\(p, _) -> p x) ps        count k = genericLength $ filter ((== k) . snd) ps -      dotPatternInside = case tree of-        Leaf {}   -> False-        RecCon {} -> any ((== DotPat) . snd) ps--  if dotPatternInside then-    typeError $ NotSupported $-      "Dot patterns inside record patterns, " ++-      "unless accompanied by data type patterns"-   else-    return $ case tree of-      Leaf p     -> (p,   s, [Left p])-      RecCon t _ -> (pat, s, [Right (count, "r", t)])+  return $ case tree of+    Leaf p     -> (p,   s, [Left p])+    RecCon t _ -> (pat, s, [Right (count, "r", t)])  ------------------------------------------------------------------------ -- Translation of patterns@@ -282,7 +267,7 @@ -- -- This function assumes that literals are never of record type. -translatePattern :: Pattern -> RecPatM (Pattern, Subst, Changes)+translatePattern :: Pattern -> RecPatM (Pattern, Substitution, Changes) translatePattern (ConP c Nothing ps) = do   (ps, s, cs) <- translatePatterns ps   return (ConP c Nothing ps, s, cs)@@ -298,7 +283,7 @@ -- | 'translatePattern' lifted to lists of arguments.  translatePatterns ::-  [Arg Pattern] -> RecPatM ([Arg Pattern], Subst, Changes)+  [Arg Pattern] -> RecPatM ([Arg Pattern], Substitution, Changes) translatePatterns ps = do   (ps', ss, cs) <- unzip3 <$> mapM (translatePattern . unArg) ps   return (ps' `withArgsFrom` ps, concat ss, concat cs)@@ -319,7 +304,7 @@  recordTree ::   Pattern ->-  RecPatM (Either (RecPatM (Pattern, Subst, Changes)) RecordTree)+  RecPatM (Either (RecPatM (Pattern, Substitution, Changes)) RecordTree) recordTree p@(ConP _ Nothing _) = return $ Left $ translatePattern p recordTree (ConP c (Just t) ps) = do   rs <- mapM (recordTree . unArg) ps@@ -329,15 +314,14 @@         (ps', ss, cs) <- unzip3 <$> mapM (either id removeTree) rs         return (ConP c (Just t) (ps' `withArgsFrom` ps),                 concat ss, concat cs)-    Right ts -> do+    Right ts -> liftTCM $ do       t <- reduce t       case t of-        Arg { unArg = El _ (Def r args) } -> do+        Arg { unArg = El _ (Def r _) } -> do           rDef <- theDef <$> getConstInfo r           case rDef of             Record { recFields = fields } -> do-              let proj p = \s t ->-                    Def (unArg p) (substs s (map hide args) ++ [defaultArg t])+              let proj p = \t -> Def (unArg p) [defaultArg t]               return $ Right $ RecCon t $ zip (map proj fields) ts             _ -> __IMPOSSIBLE__         _ -> __IMPOSSIBLE__@@ -378,7 +362,6 @@   Bind $ Abs x $ translateBody rest s $ dropBinds n' b   where n' = sum $ map n [VarPat, DotPat] translateBody (Left _ : rest) s (Bind b)   = Bind $ fmap (translateBody rest s) b-translateBody (Left _ : rest) s (NoBind b) = NoBind $ translateBody rest s b translateBody []              s (Body t)   = Body $ substs s t translateBody _               _ _          = __IMPOSSIBLE__ @@ -395,14 +378,11 @@     Nothing -> __IMPOSSIBLE__     Just k  -> Var k [] --- | @dropBinds n b@ drops the initial @n@ occurrences of 'Bind' or--- 'NoBind' from @b@.+-- | @dropBinds n b@ drops the initial @n@ occurrences of 'Bind' from @b@. ----- Precondition: @b@ has to start with @n@ occurrences of 'Bind' or--- 'NoBind'.+-- Precondition: @b@ has to start with @n@ occurrences of 'Bind'.  dropBinds :: Nat -> ClauseBody -> ClauseBody dropBinds n b          | n == 0 = b dropBinds n (Bind b)   | n > 0  = dropBinds (pred n) (absBody b)-dropBinds n (NoBind b) | n > 0  = dropBinds (pred n) b dropBinds _ _                   = __IMPOSSIBLE__

src/full/Agda/TypeChecking/Records.hs view

@@ -6,6 +6,9 @@ import Control.Arrow ((***)) import Control.Monad import Data.List+import qualified Data.Map as Map+import qualified Data.Set as Set+import Data.Function  import Agda.Syntax.Common import qualified Agda.Syntax.Concrete.Name as C@@ -26,7 +29,7 @@  -- | Order the fields of a record construction. --   Use the second argument for missing fields.-orderFields :: MonadTCM tcm => QName -> a -> [C.Name] -> [(C.Name, a)] -> tcm [a]+orderFields :: QName -> a -> [C.Name] -> [(C.Name, a)] -> TCM [a] orderFields r def xs fs = do   shouldBeNull (ys \\ nub ys) $ DuplicateFields . nub   shouldBeNull (ys \\ xs)     $ TooManyFields r@@ -53,7 +56,7 @@  -- | Get the definition for a record. Throws an exception if the name --   does not refer to a record.-getRecordDef :: MonadTCM tcm => QName -> tcm Defn+getRecordDef :: QName -> TCM Defn getRecordDef r = do   def <- theDef <$> getConstInfo r   case def of@@ -61,25 +64,37 @@     _        -> typeError $ ShouldBeRecordType (El Prop $ Def r [])  -- | Get the field names of a record.-getRecordFieldNames :: MonadTCM tcm => QName -> tcm [Arg C.Name]+getRecordFieldNames :: QName -> TCM [Arg C.Name] getRecordFieldNames r =   map (fmap (nameConcrete . qnameName)) . recFields <$> getRecordDef r +-- | Find all records with at least the given fields.+findPossibleRecords :: [C.Name] -> TCM [QName]+findPossibleRecords fields = do+  defs <- (Map.union `on` sigDefinitions) <$> getSignature <*> getImportedSignature+  let possible def = case theDef def of+        Record{ recFields = fs } -> Set.isSubsetOf given inrecord+          where inrecord = Set.fromList $ map (nameConcrete . qnameName . unArg) fs+        _ -> False+  return [ defName d | d <- Map.elems defs, possible d ]+  where+    given = Set.fromList fields+ -- | Get the field types of a record.-getRecordFieldTypes :: MonadTCM tcm => QName -> tcm Telescope+getRecordFieldTypes :: QName -> TCM Telescope getRecordFieldTypes r = recTel <$> getRecordDef r  -- | Get the type of the record constructor.-getRecordConstructorType :: MonadTCM tcm => QName -> tcm Type+getRecordConstructorType :: QName -> TCM Type getRecordConstructorType r = recConType <$> getRecordDef r  -- | Returns the given record type's constructor name (with an empty -- range).-getRecordConstructor :: MonadTCM tcm => QName -> tcm QName+getRecordConstructor :: QName -> TCM QName getRecordConstructor r = killRange <$> recCon <$> getRecordDef r  -- | Check if a name refers to a record.-isRecord :: MonadTCM tcm => QName -> tcm Bool+isRecord :: QName -> TCM Bool isRecord r = do   def <- theDef <$> getConstInfo r   return $ case def of@@ -87,15 +102,20 @@     _        -> False  -- | Check if a name refers to an eta expandable record.-isEtaRecord :: MonadTCM tcm => QName -> tcm Bool+isEtaRecord :: QName -> TCM Bool isEtaRecord r = do   def <- theDef <$> getConstInfo r   return $ case def of     Record{recEtaEquality = eta} -> eta     _                            -> False +-- | Check if a type is an eta expandable record and return the record identifier and the parameters.+isEtaRecordType :: Type -> TCM (Maybe (QName, Args))+isEtaRecordType (El _ (Def d ps)) = ifM (isEtaRecord d) (return $ Just (d, ps)) (return Nothing)+isEtaRecordType _ = return Nothing+ -- | Check if a name refers to a record constructor.-isRecordConstructor :: MonadTCM tcm => QName -> tcm Bool+isRecordConstructor :: QName -> TCM Bool isRecordConstructor c = do   def <- theDef <$> getConstInfo c   case def of@@ -103,7 +123,7 @@     _                          -> return False  -- | Check if a constructor name is the internally generated record constructor.-isGeneratedRecordConstructor :: MonadTCM tcm => QName -> tcm Bool+isGeneratedRecordConstructor :: QName -> TCM Bool isGeneratedRecordConstructor c = do   def <- theDef <$> getConstInfo c   case def of@@ -121,7 +141,7 @@      and @r : R@, @etaExpand R [] r@ is @[R.x r, R.y r, DontCare]@ -}-etaExpandRecord :: MonadTCM tcm => QName -> Args -> Term -> tcm (Telescope, Args)+etaExpandRecord :: QName -> Args -> Term -> TCM (Telescope, Args) etaExpandRecord r pars u = do   Record{ recFields = xs, recTel = tel } <- getRecordDef r   let tel' = apply tel pars@@ -131,9 +151,9 @@       -- irrelevant fields are expanded to DontCare       -- this is sound because etaExpandRecord is only called during conversion       -- WARNING: do not use etaExpandRecord to expand MetaVars!!-      let proj (Arg h Irrelevant _) = Arg h Irrelevant DontCare+      let proj (Arg h Irrelevant x) = Arg h Irrelevant $ DontCare (Def x [defaultArg u])           proj (Arg h rel x)        = Arg h rel $-            Def x $ map hide pars ++ [defaultArg u]+            Def x [defaultArg u]       reportSDoc "tc.record.eta" 20 $ vcat         [ text "eta expanding" <+> prettyTCM u <+> text ":" <+> prettyTCM r         , nest 2 $ vcat@@ -146,18 +166,18 @@     hide a = a { argHiding = Hidden }  -- | The fields should be eta contracted already.-etaContractRecord :: MonadTCM tcm => QName -> QName -> Args -> tcm Term+etaContractRecord :: QName -> QName -> Args -> TCM Term etaContractRecord r c args = do   Record{ recPars = npars, recFields = xs } <- getRecordDef r   let check a ax = do       -- @a@ is the constructor argument, @ax@ the corr. record field name         -- skip irrelevant record fields by returning DontCare         case (argRelevance a, unArg a) of-          (Irrelevant, _) -> return $ Just DontCare-          -- if @a@ is the record field name applied to (npars+1) args,+          (Irrelevant, v) -> return $ Just $ DontCare __IMPOSSIBLE__ -- thrown out later+          -- if @a@ is the record field name applied to a single argument           -- then it passes the check-          (_, Def y args) | unArg ax == y && genericLength args == npars + 1-                         -> return (Just $ unArg $ last args)+          (_, Def y [arg]) | unArg ax == y+                         -> return (Just $ unArg arg)           _              -> return Nothing       fallBack = return (Con c args)   case compare (length args) (length xs) of@@ -166,7 +186,7 @@     EQ -> do       as <- zipWithM check args xs       case sequence as of-        Just as -> case filter (DontCare /=) as of+        Just as -> case filter notDontCare as of           (a:as) ->             if all (a ==) as               then do@@ -178,6 +198,8 @@               else fallBack           _ -> fallBack -- just DontCares         _ -> fallBack  -- a Nothing+  where notDontCare (DontCare _) = False+        notDontCare _            = True  -- | Is the type a hereditarily singleton record type? May return a -- blocking metavariable.@@ -185,12 +207,19 @@ -- Precondition: The name should refer to a record type, and the -- arguments should be the parameters to the type. -isSingletonRecord ::-  MonadTCM tcm => QName -> Args -> tcm (Either MetaId Bool)-isSingletonRecord r ps =+isSingletonRecord :: QName -> Args -> TCM (Either MetaId Bool)+isSingletonRecord = isSingletonRecord' False++isSingletonRecordModuloRelevance :: QName -> Args -> TCM (Either MetaId Bool)+isSingletonRecordModuloRelevance = isSingletonRecord' True++isSingletonRecord' :: Bool -> QName -> Args -> TCM (Either MetaId Bool)+isSingletonRecord' regardIrrelevance r ps =   check =<< ((`apply` ps) <$> getRecordFieldTypes r)   where   check EmptyTel            = return (Right True)+  check (ExtendTel arg tel) | regardIrrelevance && argRelevance arg == Irrelevant =+    underAbstraction arg tel check   check (ExtendTel arg tel) = do     TelV _ t <- telView $ unArg arg     t <- reduceB $ unEl t@@ -199,7 +228,7 @@       NotBlocked (MetaV m _) -> return (Left m)       NotBlocked (Def r ps)  ->         ifM (not <$> isRecord r) (return $ Right False) $ do-          isRec <- isSingletonRecord r ps+          isRec <- isSingletonRecord' regardIrrelevance r ps           case isRec of             Left _      -> return isRec             Right False -> return isRec

src/full/Agda/TypeChecking/Records.hs-boot view

@@ -7,8 +7,8 @@ import qualified Agda.Syntax.Concrete.Name as C import Agda.TypeChecking.Monad -isRecord :: MonadTCM tcm => QName -> tcm Bool-isEtaRecord :: MonadTCM tcm => QName -> tcm Bool-getRecordFieldNames :: MonadTCM tcm => QName -> tcm [Arg C.Name]-etaContractRecord :: MonadTCM tcm => QName -> QName -> Args -> tcm Term-isGeneratedRecordConstructor :: MonadTCM tcm => QName -> tcm Bool+isRecord :: QName -> TCM Bool+isEtaRecord :: QName -> TCM Bool+getRecordFieldNames :: QName -> TCM [Arg C.Name]+etaContractRecord :: QName -> QName -> Args -> TCM Term+isGeneratedRecordConstructor :: QName -> TCM Bool

src/full/Agda/TypeChecking/Reduce.hs view

@@ -1,4 +1,5 @@-{-# LANGUAGE CPP, PatternGuards, TypeSynonymInstances #-}+{-# LANGUAGE CPP, PatternGuards,+             TypeSynonymInstances, FlexibleInstances #-}  module Agda.TypeChecking.Reduce where @@ -26,7 +27,9 @@ import Agda.TypeChecking.Free import Agda.TypeChecking.EtaContract import Agda.TypeChecking.CompiledClause+import {-# SOURCE #-} Agda.TypeChecking.Pretty +import {-# SOURCE #-} Agda.TypeChecking.Level import {-# SOURCE #-} Agda.TypeChecking.Patterns.Match import {-# SOURCE #-} Agda.TypeChecking.CompiledClause.Match @@ -35,14 +38,14 @@ #include "../undefined.h" import Agda.Utils.Impossible -traceFun :: MonadTCM tcm => String -> tcm a -> tcm a+traceFun :: String -> TCM a -> TCM a traceFun s m = do   reportSLn "tc.inst" 100 $ "[ " ++ s   x <- m   reportSLn "tc.inst" 100 $ "]"   return x -traceFun' :: (Show a, MonadTCM tcm) => String -> tcm a -> tcm a+traceFun' :: Show a => String -> TCM a -> TCM a traceFun' s m = do   reportSLn "tc.inst" 100 $ "[ " ++ s   x <- m@@ -54,7 +57,7 @@ --   Doesn't do any reduction, and preserves blocking tags (when blocking meta --   is uninstantiated). class Instantiate t where-    instantiate :: MonadTCM tcm => t -> tcm t+    instantiate :: t -> TCM t  instance Instantiate Term where   instantiate t@(MetaV x args) = do@@ -62,12 +65,31 @@     case mi of       InstV a                        -> instantiate $ a `apply` args       Open                           -> return t+      OpenIFS                        -> return t       BlockedConst _                 -> return t       PostponedTypeCheckingProblem _ -> return t       InstS _                        -> __IMPOSSIBLE__-  instantiate (Sort s) = Sort <$> instantiate s+  instantiate (Level l) = levelTm <$> instantiate l+  instantiate (Sort s) = sortTm <$> instantiate s   instantiate t = return t +instance Instantiate Level where+  instantiate (Max as) = levelMax <$> instantiate as++instance Instantiate PlusLevel where+  instantiate l@ClosedLevel{} = return l+  instantiate (Plus n a) = Plus n <$> instantiate a++instance Instantiate LevelAtom where+  instantiate l = case l of+    MetaLevel m vs -> do+      v <- instantiate (MetaV m vs)+      case v of+        MetaV m vs -> return $ MetaLevel m vs+        _          -> return $ UnreducedLevel v+    UnreducedLevel l -> UnreducedLevel <$> instantiate l+    _ -> return l+ instance Instantiate a => Instantiate (Blocked a) where   instantiate v@NotBlocked{} = return v   instantiate v@(Blocked x u) = do@@ -75,6 +97,7 @@     case mi of       InstV _                        -> notBlocked <$> instantiate u       Open                           -> return v+      OpenIFS                        -> return v       BlockedConst _                 -> return v       PostponedTypeCheckingProblem _ -> return v       InstS _                        -> __IMPOSSIBLE__@@ -83,21 +106,14 @@     instantiate (El s t) = El <$> instantiate s <*> instantiate t  instance Instantiate Sort where-    instantiate s = case s of-	MetaS x as -> do-	    mi <- mvInstantiation <$> lookupMeta x-	    case mi of-		InstS s'                       -> do-                  v <- instantiate (s' `apply` as)-                  case v of-                    Sort s -> return s-                    _      -> __IMPOSSIBLE__-		Open                           -> return s-		InstV{}                        -> __IMPOSSIBLE__-		BlockedConst{}                 -> __IMPOSSIBLE__-                PostponedTypeCheckingProblem{} -> __IMPOSSIBLE__-        _ -> return s+  instantiate s = case s of+    Type l -> levelSort <$> instantiate l+    _      -> return s +instance Instantiate Elim where+  instantiate (Apply v) = Apply <$> instantiate v+  instantiate (Proj f)  = pure $ Proj f+ instance Instantiate t => Instantiate (Abs t) where   instantiate = traverse instantiate @@ -126,15 +142,15 @@   instantiate (ValueCmp cmp t u v) = do     (t,u,v) <- instantiate (t,u,v)     return $ ValueCmp cmp t u v-  instantiate (ArgsCmp cmp t as bs) = do-    (t, as, bs) <- instantiate (t, as, bs)-    return $ ArgsCmp cmp t as bs+  instantiate (ElimCmp cmp t v as bs) =+    ElimCmp cmp <$> instantiate t <*> instantiate v <*> instantiate as <*> instantiate bs   instantiate (LevelCmp cmp u v)   = uncurry (LevelCmp cmp) <$> instantiate (u,v)   instantiate (TypeCmp cmp a b)    = uncurry (TypeCmp cmp) <$> instantiate (a,b)-  instantiate (TelCmp cmp a b)     = uncurry (TelCmp cmp)  <$> instantiate (a,b)+  instantiate (TelCmp a b cmp tela telb) = uncurry (TelCmp a b cmp)  <$> instantiate (tela,telb)   instantiate (SortCmp cmp a b)    = uncurry (SortCmp cmp) <$> instantiate (a,b)-  instantiate (Guarded c cs)       = uncurry Guarded <$> instantiate (c,cs)+  instantiate (Guarded c pid)      = Guarded <$> instantiate c <*> pure pid   instantiate (UnBlock m)          = return $ UnBlock m+  instantiate (FindInScope m)      = return $ FindInScope m   instantiate (IsEmpty t)          = IsEmpty <$> instantiate t  instance (Ord k, Instantiate e) => Instantiate (Map k e) where@@ -146,54 +162,65 @@ --  class Reduce t where-    reduce  :: MonadTCM tcm => t -> tcm t-    reduceB :: MonadTCM tcm => t -> tcm (Blocked t)+    reduce  :: t -> TCM t+    reduceB :: t -> TCM (Blocked t)      reduce  t = ignoreBlocking <$> reduceB t     reduceB t = notBlocked <$> reduce t  instance Reduce Type where-    reduce (El s t) = El <$> reduce s <*> reduce t-    reduceB (El s t) = do-      s <- reduce s-      t <- reduceB t-      return (El s <$> t)+    reduce  (El s t) = El s <$> reduce t+    reduceB (El s t) = fmap (El s) <$> reduceB t  instance Reduce Sort where     reduce s = {-# SCC "reduce<Sort>" #-}-      ifM (not <$> hasUniversePolymorphism) (red sSuc sLub s)-      $ liftTCM $ do-        suc  <- do sc <- primLevelSuc-                   return $ \x -> case x of-                                    Type n -> Type (sc `apply` [Arg NotHidden Relevant n])-                                    _      -> sSuc x-          `catchError` \_ -> return sSuc-        lub <- do mx <- primLevelMax-                  return $ \x y -> case (x, y) of-                    (Type n, Type m) -> Type (mx `apply` List.map (Arg NotHidden Relevant) [n, m])-                    _                -> sLub x y-          `catchError` \_ -> return sLub-        -- need to instantiate all meta to know if we need a DLub or a Lub-        red suc lub =<< instantiateFull s+      ifM (not <$> hasUniversePolymorphism) (red s)+      $ red =<< instantiateFull s       where-        red suc lub s = do+        red s = do           s <- instantiate s           case s of-            Suc s'     -> suc <$> reduce s'-            Lub s1 s2  -> lub <$> reduce s1 <*> reduce s2             DLub s1 s2 -> do               s <- dLub <$> reduce s1 <*> reduce s2               case s of                 DLub{}  -> return s                 _       -> reduce s   -- TODO: not so nice             Prop       -> return s-            Type s'    -> Type <$> reduce s'-            MetaS m as -> MetaS m <$> reduce as+            Type s'    -> levelSort <$> reduce s'             Inf        -> return Inf -instance Reduce t => Reduce (Abs t) where-  reduce b = Abs (absName b) <$> underAbstraction_ b reduce+instance Reduce Elim where+  reduce (Apply v) = Apply <$> reduce v+  reduce (Proj f)  = pure $ Proj f +instance Reduce Level where+  reduce  (Max as) = levelMax <$> mapM reduce as+  reduceB (Max as) = fmap levelMax . traverse id <$> traverse reduceB as++instance Reduce PlusLevel where+  reduceB l@ClosedLevel{} = return $ notBlocked l+  reduceB (Plus n l) = fmap (Plus n) <$> reduceB l++instance Reduce LevelAtom where+  reduceB l = case l of+    MetaLevel m vs   -> fromTm (MetaV m vs)+    NeutralLevel v   -> return $ NotBlocked $ NeutralLevel v+    BlockedLevel m v ->+      ifM (isInstantiatedMeta m) (fromTm v) (return $ Blocked m $ BlockedLevel m v)+    UnreducedLevel v -> fromTm v+    where+      fromTm v = do+        bv <- reduceB v+        case bv of+          Blocked m v             -> return $ Blocked m  $ BlockedLevel m v+          NotBlocked (MetaV m vs) -> return $ NotBlocked $ MetaLevel m vs+          NotBlocked v            -> return $ NotBlocked $ NeutralLevel v+++instance (Raise t, Reduce t) => Reduce (Abs t) where+  reduce b@(Abs x _) = Abs x <$> underAbstraction_ b reduce+  reduce (NoAbs x v) = NoAbs x <$> reduce v+ -- Lists are never blocked instance Reduce t => Reduce [t] where     reduce = traverse reduce@@ -210,52 +237,46 @@     reduce (x,y,z) = (,,) <$> reduce x <*> reduce y <*> reduce z  instance Reduce Term where-    reduceB v =-	{-# SCC "reduce<Term>" #-}-	do  v <- instantiate v-	    case v of-		MetaV x args -> notBlocked . MetaV x <$> reduce args-		Def f args   -> unfoldDefinition False reduceB (Def f []) f args-		Con c args   -> do-                    -- Constructors can reduce when they come from an-                    -- instantiated module.-		    v <- unfoldDefinition False reduceB (Con c []) c args-		    traverse reduceNat v-		Sort s	   -> fmap Sort <$> reduceB s-		Pi _ _	   -> return $ notBlocked v-		Fun _ _    -> return $ notBlocked v-		Lit _	   -> return $ notBlocked v-		Var _ _    -> return $ notBlocked v-		Lam _ _    -> return $ notBlocked v-		DontCare   -> return $ notBlocked v-	where-            -- NOTE: reduceNat can traverse the entire term.-	    reduceNat v@(Con c []) = do-		mz  <- getBuiltin' builtinZero-                mlz <- getBuiltin' builtinLevelZero-		case v of-                  _ | Just v == mz  -> return $ Lit $ LitInt (getRange c) 0-                    | Just v == mlz -> return $ Lit $ LitLevel (getRange c) 0-		  _		    -> return v-	    reduceNat v@(Con c [Arg NotHidden Relevant w]) = do-		ms  <- getBuiltin' builtinSuc-                mls <- getBuiltin' builtinLevelSuc-		case v of-                  _ | Just (Con c []) == ms ||-                      Just (Con c []) == mls -> inc <$> reduce w-		  _	                     -> return v-                  where-                    inc w = case w of-                      Lit (LitInt r n) -> Lit (LitInt (fuseRange c r) $ n + 1)-                      Lit (LitLevel r n) -> Lit (LitLevel (fuseRange c r) $ n + 1)-                      _                  -> Con c [Arg NotHidden Relevant w]-	    reduceNat v = return v+  reduceB v = {-# SCC "reduce<Term>" #-} do+    v <- instantiate v+    case v of+      MetaV x args -> notBlocked . MetaV x <$> reduce args+      Def f args   -> unfoldDefinition False reduceB (Def f []) f args+      Con c args   -> do+          -- Constructors can reduce when they come from an+          -- instantiated module.+          v <- unfoldDefinition False reduceB (Con c []) c args+          traverse reduceNat v+      Sort s   -> fmap sortTm <$> reduceB s+      Level l  -> fmap levelTm <$> reduceB l+      Pi _ _   -> return $ notBlocked v+      Lit _    -> return $ notBlocked v+      Var _ _  -> return $ notBlocked v+      Lam _ _  -> return $ notBlocked v+      DontCare _ -> return $ notBlocked v+    where+      -- NOTE: reduceNat can traverse the entire term.+      reduceNat v@(Con c []) = do+        mz  <- getBuiltin' builtinZero+        case v of+          _ | Just v == mz  -> return $ Lit $ LitInt (getRange c) 0+          _		    -> return v+      reduceNat v@(Con c [Arg NotHidden Relevant w]) = do+        ms  <- getBuiltin' builtinSuc+        case v of+          _ | Just (Con c []) == ms -> inc <$> reduce w+          _	                    -> return v+          where+            inc w = case w of+              Lit (LitInt r n) -> Lit (LitInt (fuseRange c r) $ n + 1)+              _                -> Con c [Arg NotHidden Relevant w]+      reduceNat v = return v  -- | If the first argument is 'True', then a single delayed clause may -- be unfolded.-unfoldDefinition :: MonadTCM tcm =>-  Bool -> (Term -> tcm (Blocked Term)) ->-  Term -> QName -> Args -> tcm (Blocked Term)+unfoldDefinition ::+  Bool -> (Term -> TCM (Blocked Term)) ->+  Term -> QName -> Args -> TCM (Blocked Term) unfoldDefinition unfoldDelayed keepGoing v0 f args =   {-# SCC "reduceDef" #-} do   info <- getConstInfo f@@ -265,11 +286,9 @@     Primitive{primAbstr = ConcreteDef, primName = x, primClauses = cls} -> do       pf <- getPrimitive x       reducePrimitive x v0 f args pf (defDelayed info)-                      (maybe [] (List.map translatedClause) cls)-                      (defCompiled info)+                      (maybe [] id cls) (defCompiled info)     _  -> reduceNormal v0 f (map notReduced args) (defDelayed info)-                       (List.map translatedClause $ defClauses info)-                       (defCompiled info)+                       (defClauses info) (defCompiled info)   where     reducePrimitive x v0 f args pf delayed cls mcc         | n < ar    = return $ notBlocked $ v0 `apply` args -- not fully applied@@ -278,47 +297,71 @@             r <- def args1             case r of               NoReduction args1' ->-                reduceNormal v0 f (args1' ++-                                   map notReduced args2)-                             delayed cls mcc+                if null cls then+                  return $ apply (Def f []) <$> traverse id (map mredToBlocked args1' ++ map notBlocked args2)+                else+                  reduceNormal v0 f (args1' +++                                     map notReduced args2)+                               delayed cls mcc               YesReduction v ->                 keepGoing $ v `apply` args2         where             n	= genericLength args             ar  = primFunArity pf             def = primFunImplementation pf+            mredToBlocked :: MaybeReduced a -> Blocked a+            mredToBlocked (MaybeRed NotReduced  x) = notBlocked x+            mredToBlocked (MaybeRed (Reduced b) x) = x <$ b +    -- reduceNormal :: Term -> QName -> [MaybeReduced (Arg Term)] -> Delayed -> [Clause] -> Maybe CompiledClauses -> TCM (Blocked Term)     reduceNormal v0 f args delayed def mcc = {-# SCC "reduceNormal" #-} do         case def of           _ | Delayed <- delayed,               not unfoldDelayed -> defaultResult           [] -> defaultResult -- no definition for head-          cls@(Clause{ clausePats = ps } : _)-            | length ps <= length args -> do-                let (args1,args2') = splitAt (length ps) args-                    args2 = map ignoreReduced args2'-                ev <- maybe (appDef' v0 cls args1)-                            (\cc -> appDef v0 cc args1) mcc-                case ev of-                  NoReduction  v -> return    $ v `apply` args2-                  YesReduction v -> keepGoing $ v `apply` args2-            | otherwise	-> defaultResult -- partial application+          cls -> do+            ev <- maybe (appDef' v0 cls args)+                        (\cc -> appDef v0 cc args) mcc+            case ev of+              NoReduction v -> do+                reportSDoc "tc.reduce" 90 $ vcat+                  [ text "*** tried to reduce " <+> prettyTCM f+                  , text "    args    " <+> prettyTCM (map (unArg . ignoreReduced) args)+                  , text "    stuck on" <+> prettyTCM (ignoreBlocking v) ]+                return v+              YesReduction v -> do+                reportSDoc "tc.reduce" 90 $ vcat+                  [ text "*** reduced definition: " <+> prettyTCM f+                  ]+                reportSDoc "tc.reduce" 100 $ text "    result" <+> prettyTCM v+                keepGoing v       where defaultResult = return $ notBlocked $ v0 `apply` (map ignoreReduced args)      -- Apply a defined function to it's arguments.     --   The original term is the first argument applied to the third.-    appDef :: MonadTCM tcm => Term -> CompiledClauses -> MaybeReducedArgs -> tcm (Reduced (Blocked Term) Term)+    appDef :: Term -> CompiledClauses -> MaybeReducedArgs -> TCM (Reduced (Blocked Term) Term)     appDef v cc args = liftTCM $ do       r <- matchCompiled cc args       case r of         YesReduction t    -> return $ YesReduction t         NoReduction args' -> return $ NoReduction $ fmap (apply v) args' -    appDef' :: MonadTCM tcm => Term -> [Clause] -> MaybeReducedArgs -> tcm (Reduced (Blocked Term) Term)-    appDef' v cls args = {-# SCC "appDef" #-} do-      goCls cls (map ignoreReduced args) where+    appDef' :: Term -> [Clause] -> MaybeReducedArgs -> TCM (Reduced (Blocked Term) Term)+    appDef' _ [] _ = {- ' -} __IMPOSSIBLE__+    appDef' v cls@(Clause {clausePats = ps} : _) args+      | m < n     = return $ NoReduction $ notBlocked $ v `apply` map ignoreReduced args+      | otherwise = do+        let (args0, args1) = splitAt n args+        r <- goCls cls (map ignoreReduced args0)+        case r of+          YesReduction u -> return $ YesReduction $ u `apply` map ignoreReduced args1+          NoReduction v  -> return $ NoReduction $ (`apply` map ignoreReduced args1) <$> v+      where -        goCls :: MonadTCM tcm => [Clause] -> Args -> tcm (Reduced (Blocked Term) Term)+        n = genericLength ps+        m = genericLength args++        goCls :: [Clause] -> Args -> TCM (Reduced (Blocked Term) Term)         goCls [] args = typeError $ IncompletePatternMatching v args         goCls (cl@(Clause { clausePats = pats                           , clauseBody = body }) : cls) args = do@@ -334,18 +377,15 @@                       app args' body)                   | otherwise	  -> return $ NoReduction $ notBlocked $ v `apply` args -        hasBody (Body _)	 = True-        hasBody NoBody		 = False-        hasBody (Bind (Abs _ b)) = hasBody b-        hasBody (NoBind b)	 = hasBody b+        hasBody (Body _) = True+        hasBody NoBody   = False+        hasBody (Bind b) = hasBody (unAbs b) -        app []		 (Body v')	     = v'-        app (arg : args) (Bind (Abs _ body)) = {-# SCC "instRHS" #-} app args $ subst arg body -- CBN-        app (_   : args) (NoBind body)	     = app args body-        app  _		  NoBody	     = __IMPOSSIBLE__-        app (_ : _)	 (Body _)	     = __IMPOSSIBLE__-        app []		 (Bind _)	     = __IMPOSSIBLE__-        app []		 (NoBind _)	     = __IMPOSSIBLE__+        app []		 (Body v') = v'+        app (arg : args) (Bind b)  = app args $ absApp b arg -- CBN+        app  _		  NoBody   = __IMPOSSIBLE__+        app (_ : _)	 (Body _)  = __IMPOSSIBLE__+        app []		 (Bind _)  = __IMPOSSIBLE__   instance Reduce a => Reduce (Closure a) where@@ -360,15 +400,15 @@   reduce (ValueCmp cmp t u v) = do     (t,u,v) <- reduce (t,u,v)     return $ ValueCmp cmp t u v-  reduce (ArgsCmp cmp t us vs) = do-    (t,us,vs) <- reduce (t,us,vs)-    return $ ArgsCmp cmp t us vs+  reduce (ElimCmp cmp t v as bs) =+    ElimCmp cmp <$> reduce t <*> reduce v <*> reduce as <*> reduce bs   reduce (LevelCmp cmp u v)   = uncurry (LevelCmp cmp) <$> reduce (u,v)   reduce (TypeCmp cmp a b)    = uncurry (TypeCmp cmp) <$> reduce (a,b)-  reduce (TelCmp  cmp a b)    = uncurry (TelCmp cmp)  <$> reduce (a,b)+  reduce (TelCmp a b cmp tela telb) = uncurry (TelCmp a b cmp)  <$> reduce (tela,telb)   reduce (SortCmp cmp a b)    = uncurry (SortCmp cmp) <$> reduce (a,b)-  reduce (Guarded c cs)       = uncurry Guarded <$> reduce (c,cs)+  reduce (Guarded c pid)      = Guarded <$> reduce c <*> pure pid   reduce (UnBlock m)          = return $ UnBlock m+  reduce (FindInScope m)      = return $ FindInScope m   reduce (IsEmpty t)          = IsEmpty <$> reduce t  instance (Ord k, Reduce e) => Reduce (Map k e) where@@ -379,18 +419,15 @@ ---------------------------------------------------------------------------  class Normalise t where-    normalise :: MonadTCM tcm => t -> tcm t+    normalise :: t -> TCM t  instance Normalise Sort where     normalise s = do       s <- reduce s       case s of-        Suc s'     -> sSuc <$> normalise s'-        Lub s1 s2  -> sLub <$> normalise s1 <*> normalise s2         DLub s1 s2 -> dLub <$> normalise s1 <*> normalise s2         Prop       -> return s-        Type s'    -> Type <$> normalise s'-        MetaS m as -> MetaS m <$> normalise as+        Type s     -> levelSort <$> normalise s         Inf        -> return Inf  instance Normalise Type where@@ -405,20 +442,40 @@ 		Def f vs    -> Def f <$> normalise vs 		MetaV x vs  -> MetaV x <$> normalise vs 		Lit _	    -> return v+                Level l     -> levelTm <$> normalise l 		Lam h b	    -> Lam h <$> normalise b-		Sort s	    -> Sort <$> normalise s+		Sort s	    -> sortTm <$> normalise s 		Pi a b	    -> uncurry Pi <$> normalise (a,b)-		Fun a b     -> uncurry Fun <$> normalise (a,b)-                DontCare    -> return v+                DontCare _  -> return v +instance Normalise Elim where+  normalise (Apply v) = Apply <$> normalise v+  normalise (Proj f)  = pure $ Proj f++instance Normalise Level where+  normalise (Max as) = levelMax <$> normalise as++instance Normalise PlusLevel where+  normalise l@ClosedLevel{} = return l+  normalise (Plus n l) = Plus n <$> normalise l++instance Normalise LevelAtom where+  normalise l = do+    l <- reduce l+    case l of+      MetaLevel m vs   -> MetaLevel m <$> normalise vs+      BlockedLevel m v -> BlockedLevel m <$> normalise v+      NeutralLevel v   -> NeutralLevel <$> normalise v+      UnreducedLevel{} -> __IMPOSSIBLE__    -- I hope+ instance Normalise ClauseBody where     normalise (Body   t) = Body   <$> normalise t     normalise (Bind   b) = Bind   <$> normalise b-    normalise (NoBind b) = NoBind <$> normalise b     normalise  NoBody	 = return NoBody -instance Normalise t => Normalise (Abs t) where-    normalise a = Abs (absName a) <$> underAbstraction_ a normalise+instance (Raise t, Normalise t) => Normalise (Abs t) where+    normalise a@(Abs x _) = Abs x <$> underAbstraction_ a normalise+    normalise (NoAbs x v) = NoAbs x <$> normalise v  instance Normalise t => Normalise (Arg t) where     normalise = traverse normalise@@ -439,23 +496,26 @@ 	x <- enterClosure cl normalise 	return $ cl { clValue = x } -instance Normalise a => Normalise (Tele a) where+instance (Raise a, Normalise a) => Normalise (Tele a) where   normalise EmptyTel        = return EmptyTel   normalise (ExtendTel a b) = uncurry ExtendTel <$> normalise (a, b) +instance Normalise ProblemConstraint where+  normalise (PConstr pid c) = PConstr pid <$> normalise c+ instance Normalise Constraint where   normalise (ValueCmp cmp t u v) = do     (t,u,v) <- normalise (t,u,v)     return $ ValueCmp cmp t u v-  normalise (ArgsCmp cmp t u v) = do-    (t,u,v) <- normalise (t,u,v)-    return $ ArgsCmp cmp t u v+  normalise (ElimCmp cmp t v as bs) =+    ElimCmp cmp <$> normalise t <*> normalise v <*> normalise as <*> normalise bs   normalise (LevelCmp cmp u v)   = uncurry (LevelCmp cmp) <$> normalise (u,v)   normalise (TypeCmp cmp a b)    = uncurry (TypeCmp cmp) <$> normalise (a,b)-  normalise (TelCmp cmp a b)     = uncurry (TelCmp cmp)  <$> normalise (a,b)+  normalise (TelCmp a b cmp tela telb) = uncurry (TelCmp a b cmp) <$> normalise (tela,telb)   normalise (SortCmp cmp a b)    = uncurry (SortCmp cmp) <$> normalise (a,b)-  normalise (Guarded c cs)       = uncurry Guarded <$> normalise (c,cs)+  normalise (Guarded c pid)      = Guarded <$> normalise c <*> pure pid   normalise (UnBlock m)          = return $ UnBlock m+  normalise (FindInScope m)      = return $ FindInScope m   normalise (IsEmpty t)          = IsEmpty <$> normalise t  instance Normalise Pattern where@@ -482,7 +542,7 @@ -- How can we express this? We need higher order classes!  class InstantiateFull t where-    instantiateFull :: MonadTCM tcm => t -> tcm t+    instantiateFull :: t -> TCM t  instance InstantiateFull Name where     instantiateFull = return@@ -491,11 +551,8 @@     instantiateFull s = do 	s <- instantiate s 	case s of-	    MetaS x as -> MetaS x <$> instantiateFull as-	    Type n     -> Type <$> instantiateFull n+	    Type n     -> levelSort <$> instantiateFull n 	    Prop       -> return s-	    Suc s      -> sSuc <$> instantiateFull s-	    Lub s1 s2  -> sLub <$> instantiateFull s1 <*> instantiateFull s2 	    DLub s1 s2 -> dLub <$> instantiateFull s1 <*> instantiateFull s2             Inf        -> return s @@ -513,12 +570,33 @@           Def f vs    -> Def f <$> instantiateFull vs           MetaV x vs  -> MetaV x <$> instantiateFull vs           Lit _	      -> return v+          Level l     -> levelTm <$> instantiateFull l           Lam h b     -> Lam h <$> instantiateFull b-          Sort s      -> Sort <$> instantiateFull s+          Sort s      -> sortTm <$> instantiateFull s           Pi a b      -> uncurry Pi <$> instantiateFull (a,b)-          Fun a b     -> uncurry Fun <$> instantiateFull (a,b)-          DontCare    -> return v+          DontCare v  -> DontCare <$> instantiateFull v +instance InstantiateFull Level where+  instantiateFull (Max as) = levelMax <$> instantiateFull as++instance InstantiateFull PlusLevel where+  instantiateFull l@ClosedLevel{} = return l+  instantiateFull (Plus n l) = Plus n <$> instantiateFull l++instance InstantiateFull LevelAtom where+  instantiateFull l = case l of+    MetaLevel m vs -> do+      v <- instantiateFull (MetaV m vs)+      case v of+        MetaV m vs -> return $ MetaLevel m vs+        _          -> return $ UnreducedLevel v+    NeutralLevel v -> NeutralLevel <$> instantiateFull v+    BlockedLevel m v ->+      ifM (isInstantiatedMeta m)+          (UnreducedLevel <$> instantiateFull v)+          (BlockedLevel m <$> instantiateFull v)+    UnreducedLevel v -> UnreducedLevel <$> instantiateFull v+ instance InstantiateFull Pattern where     instantiateFull v@VarP{}       = return v     instantiateFull (DotP t)       = DotP <$> instantiateFull t@@ -528,11 +606,11 @@ instance InstantiateFull ClauseBody where     instantiateFull (Body   t) = Body   <$> instantiateFull t     instantiateFull (Bind   b) = Bind   <$> instantiateFull b-    instantiateFull (NoBind b) = NoBind <$> instantiateFull b     instantiateFull  NoBody    = return NoBody -instance InstantiateFull t => InstantiateFull (Abs t) where-    instantiateFull a = Abs (absName a) <$> underAbstraction_ a instantiateFull+instance (Raise t, InstantiateFull t) => InstantiateFull (Abs t) where+    instantiateFull a@(Abs x _) = Abs x <$> underAbstraction_ a instantiateFull+    instantiateFull (NoAbs x a) = NoAbs x <$> instantiateFull a  instance InstantiateFull t => InstantiateFull (Arg t) where     instantiateFull = traverse instantiateFull@@ -553,22 +631,29 @@ 	x <- enterClosure cl instantiateFull 	return $ cl { clValue = x } +instance InstantiateFull ProblemConstraint where+  instantiateFull (PConstr p c) = PConstr p <$> instantiateFull c+ instance InstantiateFull Constraint where   instantiateFull c = case c of     ValueCmp cmp t u v -> do       (t,u,v) <- instantiateFull (t,u,v)       return $ ValueCmp cmp t u v-    ArgsCmp cmp t u v -> do-      (t,u,v) <- instantiateFull (t,u,v)-      return $ ArgsCmp cmp t u v+    ElimCmp cmp t v as bs ->+      ElimCmp cmp <$> instantiateFull t <*> instantiateFull v <*> instantiateFull as <*> instantiateFull bs     LevelCmp cmp u v   -> uncurry (LevelCmp cmp) <$> instantiateFull (u,v)     TypeCmp cmp a b    -> uncurry (TypeCmp cmp) <$> instantiateFull (a,b)-    TelCmp cmp a b     -> uncurry (TelCmp cmp)  <$> instantiateFull (a,b)+    TelCmp a b cmp tela telb -> uncurry (TelCmp a b cmp) <$> instantiateFull (tela,telb)     SortCmp cmp a b    -> uncurry (SortCmp cmp) <$> instantiateFull (a,b)-    Guarded c cs       -> uncurry Guarded <$> instantiateFull (c,cs)+    Guarded c pid      -> Guarded <$> instantiateFull c <*> pure pid     UnBlock m          -> return $ UnBlock m+    FindInScope m      -> return $ FindInScope m     IsEmpty t          -> IsEmpty <$> instantiateFull t +instance InstantiateFull Elim where+  instantiateFull (Apply v) = Apply <$> instantiateFull v+  instantiateFull (Proj f)  = pure $ Proj f+ instance (Ord k, InstantiateFull e) => InstantiateFull (Map k e) where     instantiateFull = traverse instantiateFull @@ -584,7 +669,7 @@ instance InstantiateFull Section where   instantiateFull (Section tel n) = flip Section n <$> instantiateFull tel -instance InstantiateFull a => InstantiateFull (Tele a) where+instance (Raise a, InstantiateFull a) => InstantiateFull (Tele a) where   instantiateFull EmptyTel = return EmptyTel   instantiateFull (ExtendTel a b) = uncurry ExtendTel <$> instantiateFull (a, b) @@ -592,9 +677,9 @@     instantiateFull = return  instance InstantiateFull Definition where-    instantiateFull (Defn rel x t df i d) = do+    instantiateFull (Defn rel x t df i c d) = do       (t, (df, d)) <- instantiateFull (t, (df, d))-      return $ Defn rel x t df i d+      return $ Defn rel x t df i c d  instance InstantiateFull a => InstantiateFull (Open a) where   instantiateFull (OpenThing n a) = OpenThing n <$> instantiateFull a@@ -604,6 +689,9 @@  instance InstantiateFull DisplayTerm where   instantiateFull (DTerm v)	   = DTerm <$> instantiateFull v+  instantiateFull (DDot  v)	   = DDot  <$> instantiateFull v+  instantiateFull (DCon c vs)	   = DCon c <$> instantiateFull vs+  instantiateFull (DDef c vs)	   = DDef c <$> instantiateFull vs   instantiateFull (DWithApp vs ws) = uncurry DWithApp <$> instantiateFull (vs, ws)  instance InstantiateFull Defn where@@ -641,10 +729,6 @@   instantiateFull (Done m t)  = Done m <$> instantiateFull t   instantiateFull (Case n bs) = Case n <$> instantiateFull bs -instance InstantiateFull Clauses where-    instantiateFull (Clauses c tc) =-       Clauses <$> instantiateFull c <*> instantiateFull tc- instance InstantiateFull Clause where     instantiateFull (Clause r tel perm ps b) =        Clause r <$> instantiateFull tel@@ -669,12 +753,13 @@ instance InstantiateFull a => InstantiateFull (Maybe a) where   instantiateFull = mapM instantiateFull -telViewM :: MonadTCM tcm => Type -> tcm TelView+-- | @telViewM t@ is like @telView' t@, but it reduces @t@ to expose+--   function type constructors.+telViewM :: Type -> TCM TelView telViewM t = do-  t <- reduce t+  t <- reduce t -- also instantiates meta if in head position   case unEl t of-    Pi a (Abs x b) -> absV a x <$> telViewM b-    Fun a b	   -> absV a "_" <$> telViewM (raise 1 b)-    _		   -> return $ TelV EmptyTel t+    Pi a b -> absV a (absName b) <$> telViewM (absBody b)+    _      -> return $ TelV EmptyTel t   where     absV a x (TelV tel t) = TelV (ExtendTel a (Abs x tel)) t

src/full/Agda/TypeChecking/Rules/Builtin.hs view

@@ -1,15 +1,17 @@ {-# LANGUAGE PatternGuards, CPP #-}-module Agda.TypeChecking.Rules.Builtin where+module Agda.TypeChecking.Rules.Builtin (bindBuiltin, bindPostulatedName) where  import Control.Applicative import Control.Monad import Control.Monad.Error import Data.Maybe+import Data.List (find)  import qualified Agda.Syntax.Abstract as A import Agda.Syntax.Internal import Agda.Syntax.Common +import Agda.TypeChecking.EtaContract import Agda.TypeChecking.Monad import Agda.TypeChecking.Monad.Builtin import Agda.TypeChecking.Conversion@@ -19,7 +21,7 @@ import Agda.TypeChecking.Reduce import Agda.TypeChecking.Pretty -import Agda.TypeChecking.Rules.Term ( checkExpr )+import Agda.TypeChecking.Rules.Term ( checkExpr , inferExpr ) import {-# SOURCE #-} Agda.TypeChecking.Rules.Builtin.Coinduction  import Agda.Utils.Size@@ -31,158 +33,117 @@ -- * Checking builtin pragmas --------------------------------------------------------------------------- --- Buitin datatypes and the number of constructors-builtinDatatypes :: [(String, Int)]-builtinDatatypes =-  [ (builtinList, 2)-  , (builtinBool, 2)-  , (builtinNat, 2)-  , (builtinLevel, 2)+coreBuiltins :: [BuiltinInfo]+coreBuiltins = map (\(x,z) -> BuiltinInfo x z)+  [ (builtinList               |-> BuiltinData (tset --> tset) [builtinNil, builtinCons])+  , (builtinArg                |-> BuiltinData (tset --> tset) [builtinArgArg])+  , (builtinBool               |-> BuiltinData tset [builtinTrue, builtinFalse])+  , (builtinNat                |-> BuiltinData tset [builtinZero, builtinSuc])+  , (builtinLevel              |-> BuiltinPostulate tset)+  , (builtinInteger            |-> BuiltinPostulate tset)+  , (builtinFloat              |-> BuiltinPostulate tset)+  , (builtinChar               |-> BuiltinPostulate tset)+  , (builtinString             |-> BuiltinPostulate tset)+  , (builtinQName              |-> BuiltinPostulate tset)+  , (builtinIO                 |-> BuiltinPostulate (tset --> tset))+  , (builtinAgdaSort           |-> BuiltinData tset [builtinAgdaSortSet, builtinAgdaSortLit, builtinAgdaSortUnsupported])+  , (builtinAgdaType           |-> BuiltinData tset [builtinAgdaTypeEl])+  , (builtinAgdaTerm           |-> BuiltinData tset+                                     [builtinAgdaTermVar, builtinAgdaTermLam+                                     ,builtinAgdaTermDef, builtinAgdaTermCon+                                     ,builtinAgdaTermPi, builtinAgdaTermSort+                                     ,builtinAgdaTermUnsupported])+  , (builtinEquality           |-> BuiltinData (hPi "a" (el primLevel) $+                                                hPi "A" (return $ sort $ varSort 0) $+                                                (El (varSort 1) <$> var 0) -->+                                                (El (varSort 1) <$> var 0) -->+                                                return (sort $ varSort 1))+                                               [builtinRefl])+  , (builtinHiding             |-> BuiltinData tset [builtinHidden, builtinInstance, builtinVisible])+  , (builtinRelevance          |-> BuiltinData tset [builtinRelevant, builtinIrrelevant])+  , (builtinRefl               |-> BuiltinDataCons (hPi "a" (el primLevel) $ hPi "A" (return $ sort $ varSort 0) $+                                                    hPi "x" (El (varSort 1) <$> var 0) $+                                                    El (varSort 2) <$> primEquality <#> var 2 <#> var 1 <@> var 0 <@> var 0))+  , (builtinNil                |-> BuiltinDataCons (hPi "A" tset (el (list v0))))+  , (builtinCons               |-> BuiltinDataCons (hPi "A" tset (tv0 --> el (list v0) --> el (list v0))))+  , (builtinZero               |-> BuiltinDataCons tnat)+  , (builtinSuc                |-> BuiltinDataCons (tnat --> tnat))+  , (builtinTrue               |-> BuiltinDataCons tbool)+  , (builtinFalse              |-> BuiltinDataCons tbool)+  , (builtinArgArg             |-> BuiltinDataCons (hPi "A" tset (thiding --> trelevance --> tv0 --> targ tv0)))+  , (builtinAgdaTypeEl         |-> BuiltinDataCons (tsort --> tterm --> ttype))+  , (builtinAgdaTermVar        |-> BuiltinDataCons (tnat --> targs --> tterm))+  , (builtinAgdaTermLam        |-> BuiltinDataCons (thiding --> tterm --> tterm))+  , (builtinAgdaTermDef        |-> BuiltinDataCons (tqname --> targs --> tterm))+  , (builtinAgdaTermCon        |-> BuiltinDataCons (tqname --> targs --> tterm))+  , (builtinAgdaTermPi         |-> BuiltinDataCons (targ ttype --> ttype --> tterm))+  , (builtinAgdaTermSort       |-> BuiltinDataCons (tsort --> tterm))+  , (builtinAgdaTermUnsupported|-> BuiltinDataCons tterm)+  , (builtinHidden             |-> BuiltinDataCons thiding)+  , (builtinInstance           |-> BuiltinDataCons thiding)+  , (builtinVisible            |-> BuiltinDataCons thiding)+  , (builtinRelevant           |-> BuiltinDataCons trelevance)+  , (builtinIrrelevant         |-> BuiltinDataCons trelevance)+  , (builtinSize               |-> BuiltinPostulate tset)+  , (builtinSizeSuc            |-> BuiltinPostulate (tsize --> tsize))+  , (builtinSizeInf            |-> BuiltinPostulate tsize)+  , (builtinAgdaSortSet        |-> BuiltinDataCons (tterm --> tsort))+  , (builtinAgdaSortLit        |-> BuiltinDataCons (tnat --> tsort))+  , (builtinAgdaSortUnsupported|-> BuiltinDataCons tsort)+  , (builtinNatPlus            |-> BuiltinPrim "primNatPlus" verifyPlus)+  , (builtinNatMinus           |-> BuiltinPrim "primNatMinus" verifyMinus)+  , (builtinNatTimes           |-> BuiltinPrim "primNatTimes" verifyTimes)+  , (builtinNatDivSucAux       |-> BuiltinPrim "primNatDivSucAux" verifyDivSucAux)+  , (builtinNatModSucAux       |-> BuiltinPrim "primNatModSucAux" verifyModSucAux)+  , (builtinNatEquals          |-> BuiltinPrim "primNatEquality" verifyEquals)+  , (builtinNatLess            |-> BuiltinPrim "primNatLess" verifyLess)+  , (builtinLevelZero          |-> BuiltinPrim "primLevelZero" (const $ return ()))+  , (builtinLevelSuc           |-> BuiltinPrim "primLevelSuc" (const $ return ()))+  , (builtinLevelMax           |-> BuiltinPrim "primLevelMax" verifyMax)+  , (builtinAgdaFunDef                |-> BuiltinPostulate tset) -- internally this is QName+  , (builtinAgdaDataDef               |-> BuiltinPostulate tset) -- internally this is QName+  , (builtinAgdaRecordDef             |-> BuiltinPostulate tset) -- internally this is QName+  , (builtinAgdaDefinition            |-> BuiltinData tset [builtinAgdaDefinitionFunDef+                                                           ,builtinAgdaDefinitionDataDef+                                                           ,builtinAgdaDefinitionDataConstructor+                                                           ,builtinAgdaDefinitionRecordDef+                                                           ,builtinAgdaDefinitionPostulate+                                                           ,builtinAgdaDefinitionPrimitive])+  , (builtinAgdaDefinitionFunDef          |-> BuiltinDataCons (tfun --> tdefn))+  , (builtinAgdaDefinitionDataDef         |-> BuiltinDataCons (tdtype --> tdefn))+  , (builtinAgdaDefinitionDataConstructor |-> BuiltinDataCons tdefn)+  , (builtinAgdaDefinitionRecordDef       |-> BuiltinDataCons (trec --> tdefn))+  , (builtinAgdaDefinitionPostulate       |-> BuiltinDataCons tdefn)+  , (builtinAgdaDefinitionPrimitive       |-> BuiltinDataCons tdefn)   ]--inductiveCheck :: String -> Term -> TCM ()-inductiveCheck b t =-  case lookup b builtinDatatypes of-    Nothing -> return ()-    Just n  -> do-      t <- normalise t-      let err = typeError (NotInductive t)-      case t of-        Def t _ -> do-          t <- theDef <$> getConstInfo t-          case t of-            Datatype { dataInduction = Inductive-                     , dataCons      = cs-                     }-              | length cs == n -> return ()-              | otherwise ->-                typeError $ GenericError $ unwords-                            [ "The builtin", b-                            , "must be a datatype with", show n-                            , "constructors" ]-            _ -> err-        _ -> err--bindBuiltinType :: String -> A.Expr -> TCM ()-bindBuiltinType b e = do-    let s = sort $ mkType 0-    reportSDoc "tc.builtin" 20 $ text "checking builtin type" <+> prettyA e <+> text ":" <+> text (show s)-    t <- checkExpr e (sort $ mkType 0)-    inductiveCheck b t-    bindBuiltinName b t--    -- NAT and LEVEL must be different. (Why?)-    when (b `elem` [builtinNat, builtinLevel]) $ do-      nat   <- getBuiltin' builtinNat-      level <- getBuiltin' builtinLevel-      case (nat, level) of-        (Just nat, Just level) -> do-          Def nat   _ <- normalise nat-          Def level _ <- normalise level-          when (nat == level) $ typeError $ GenericError $-            builtinNat ++ " and " ++ builtinLevel ++-            " have to be different types."-        _ -> return ()--bindBuiltinBool :: String -> A.Expr -> TCM Term-bindBuiltinBool b e = do-    bool <- primBool-    checkExpr e $ El (mkType 0) bool---- | Bind something of type @Set -> Set@.-bindBuiltinType1 :: String -> A.Expr -> TCM ()-bindBuiltinType1 thing e = do-    let set      = sort (mkType 0)-        setToSet = El (mkType 1) $ Fun (defaultArg set) set-    f <- checkExpr e setToSet-    inductiveCheck thing f-    bindBuiltinName thing f--bindBuiltinZero' :: String -> TCM Term -> A.Expr -> TCM Term-bindBuiltinZero' bZero pNat e = do-    nat  <- pNat-    checkExpr e (El (mkType 0) nat)--bindBuiltinSuc' :: String -> TCM Term -> A.Expr -> TCM Term-bindBuiltinSuc' bSuc pNat e = do-    nat  <- pNat-    let nat' = El (mkType 0) nat-        natToNat = El (mkType 0) $ Fun (defaultArg nat') nat'-    checkExpr e natToNat--bindBuiltinZero e = bindBuiltinZero' builtinZero primNat e-bindBuiltinSuc  e = bindBuiltinSuc'  builtinSuc primNat e--bindBuiltinLevelZero e = bindBuiltinZero' builtinLevelZero primLevel e-bindBuiltinLevelSuc  e = bindBuiltinSuc'  builtinLevelSuc  primLevel e--typeOfSizeInf :: TCM Type-typeOfSizeInf = do-    sz  <- primSize-    return $ (El (mkType 0) sz)--typeOfSizeSuc :: TCM Type-typeOfSizeSuc = do-    sz  <- primSize-    let sz' = El (mkType 0) sz-    return $ El (mkType 0) $ Fun (defaultArg sz') sz'---- | Built-in nil should have type @{A:Set} -> List A@-bindBuiltinNil :: A.Expr -> TCM Term-bindBuiltinNil e = do-    list' <- primList-    let set     = sort (mkType 0)-        list a  = El (mkType 0) (list' `apply` [defaultArg a])-        nilType = telePi (telFromList [Arg Hidden Relevant ("A",set)]) $ list (Var 0 [])-    checkExpr e nilType---- | Built-in cons should have type @{A:Set} -> A -> List A -> List A@-bindBuiltinCons :: A.Expr -> TCM Term-bindBuiltinCons e = do-    list' <- primList-    let set       = sort (mkType 0)-        el        = El (mkType 0)-        a         = Var 0 []-        list x    = el $ list' `apply` [defaultArg x]-        hPi x a b = telePi (telFromList [Arg Hidden Relevant (x,a)]) b-        fun a b   = el $ Fun (defaultArg a) b-        consType  = hPi "A" set $ el a `fun` (list a `fun` list a)-    checkExpr e consType--bindBuiltinPrimitive :: String -> String -> A.Expr -> (Term -> TCM ()) -> TCM ()-bindBuiltinPrimitive name builtin (A.ScopedExpr scope e) verify = do-  setScope scope-  bindBuiltinPrimitive name builtin e verify-bindBuiltinPrimitive name builtin e@(A.Def qx) verify = do-    PrimImpl t pf <- lookupPrimitiveFunction name-    v <- checkExpr e t+  where+        (|->) = (,) -    verify v+        v0 = var 0+        v1 = var 1 -    info <- getConstInfo qx-    let cls = defClauses info-        a   = defAbstract info-        mcc = defCompiled info-    bindPrimitive name $ pf { primFunName = qx }-    addConstant qx $ info { theDef = Primitive a name (Just cls) mcc }+        tv0,tv1 :: TCM Type+        tv0 = el v0+        tv1 = el v1 -    -- needed? yes, for checking equations for mul-    bindBuiltinName builtin v-bindBuiltinPrimitive _ b _ _ = typeError $ GenericError $ "Builtin " ++ b ++ " must be bound to a function"+        arg :: TCM Term -> TCM Term+        arg t = primArg <@> t -builtinPrimitives :: [ (String, (String, Term -> TCM ())) ]-builtinPrimitives =-    [ "NATPLUS"       |-> ("primNatPlus", verifyPlus)-    , "NATMINUS"      |-> ("primNatMinus", verifyMinus)-    , "NATTIMES"      |-> ("primNatTimes", verifyTimes)-    , "NATDIVSUCAUX"  |-> ("primNatDivSucAux", verifyDivSucAux)-    , "NATMODSUCAUX"  |-> ("primNatModSucAux", verifyModSucAux)-    , "NATEQUALS"     |-> ("primNatEquality", verifyEquals)-    , "NATLESS"       |-> ("primNatLess", verifyLess)-    , builtinLevelMax |-> ("primLevelMax", verifyMax)-    ]-    where-        (|->) = (,)+        targ x     = el (arg (fmap unEl x))+        targs      = el (list (arg primAgdaTerm))+        tterm      = el primAgdaTerm+        tqname     = el primQName+        tnat       = el primNat+        tsize      = el primSize+        tbool      = el primBool+        thiding    = el primHiding+        trelevance = el primRelvance+        ttype      = el primAgdaType+        tsort      = el primAgdaSort+        tdefn      = el primAgdaDefinition+        tfun       = el primAgdaFunDef+        tdtype     = el primAgdaDataDef+        trec       = el primAgdaRecordDef          verifyPlus plus =             verify ["n","m"] $ \(@@) zero suc (==) choice -> do@@ -276,16 +237,7 @@             (suc n < suc m) === (n < m)             (zero  < suc m) === true -        verifyMax maxV =-            verify' primLevel primLevelZero primLevelSuc ["n","m"] $-              \(@@) zero suc (==) choice -> do-                let m = Var 0 []-                    n = Var 1 []-                    max x y = maxV @@ x @@ y--                max zero (suc n)    == suc n-                max (suc n) zero    == suc n-                max (suc n) (suc m) == suc (max n m)+        verifyMax maxV = return ()  -- TODO: make max a postulate          verify xs = verify' primNat primZero primSuc xs @@ -304,35 +256,26 @@             xs <- mapM freshName_ xs             addCtxs xs (defaultArg nat) $ f (@@) zero suc (==) choice -bindBuiltinEquality :: A.Expr -> TCM ()-bindBuiltinEquality e = do-  let set       = sort (mkType 0)-      el        = El (mkType 0)-      a         = Var 0 []-      hPi x a b = telePi (telFromList [Arg Hidden Relevant (x,a)]) b-      fun a b   = El (mkType 1) $ Fun (defaultArg a) b-      eqType    = hPi "A" set $ el a `fun` (el a `fun` set)-  eq <- checkExpr e eqType-  bindBuiltinName builtinEquality eq --bindBuiltinRefl :: A.Expr -> TCM Term-bindBuiltinRefl e = do-  eq' <- primEquality-  let set       = sort (mkType 0)-      el        = El (mkType 0)-      v0        = Var 0 []-      v1        = Var 1 []-      hPi x a b = telePi (telFromList [Arg Hidden Relevant (x, a)]) b-      fun a b   = el $ Fun (defaultArg a) b-      eq a b c  = el $ eq' `apply` [Arg Hidden Relevant a, defaultArg b, defaultArg c]-      reflType  = hPi "A" set $ hPi "x" (el v0) $ eq v1 v0 v0-  checkExpr e reflType--bindBuiltinDummyConstructor :: A.Expr -> TCM Term-bindBuiltinDummyConstructor (A.ScopedExpr _ e) = bindBuiltinDummyConstructor e-bindBuiltinDummyConstructor (A.Con (AmbQ [c])) = return (Con c [])-bindBuiltinDummyConstructor e = typeError $ GenericError "bad BUILTIN"+inductiveCheck :: String -> Int -> Term -> TCM ()+inductiveCheck b n t = do+    t <- etaContract =<< normalise t+    let err = typeError (NotInductive t)+    case t of+      Def t _ -> do+        t <- theDef <$> getConstInfo t+        case t of+          Datatype { dataInduction = Inductive+                   , dataCons      = cs+                   }+            | length cs == n -> return ()+            | otherwise ->+              typeError $ GenericError $ unwords+                          [ "The builtin", b+                          , "must be a datatype with", show n+                          , "constructors" ]+          _ -> err+      _ -> err  -- | @bindPostulatedName builtin e m@ checks that @e@ is a postulated -- name @q@, and binds the builtin @builtin@ to the term @m q def@,@@ -355,57 +298,81 @@   getName (A.ScopedExpr _ e) = getName e   getName _                  = err --- | Builtin constructors-builtinConstructors :: [(String, A.Expr -> TCM Term)]-builtinConstructors =-  [ (builtinNil,       bindBuiltinNil               )-  , (builtinCons,      bindBuiltinCons              )-  , (builtinZero,      bindBuiltinZero              )-  , (builtinSuc,       bindBuiltinSuc               )-  , (builtinTrue,      bindBuiltinBool builtinTrue  )-  , (builtinFalse,     bindBuiltinBool builtinFalse )-  , (builtinRefl,      bindBuiltinRefl              )-  , (builtinLevelZero, bindBuiltinLevelZero         )-  , (builtinLevelSuc,  bindBuiltinLevelSuc          )-  , (builtinArgArg,    bindBuiltinDummyConstructor  )-  , (builtinAgdaTermVar,    bindBuiltinDummyConstructor  )-  , (builtinAgdaTermLam,    bindBuiltinDummyConstructor  )-  , (builtinAgdaTermDef,    bindBuiltinDummyConstructor  )-  , (builtinAgdaTermCon,    bindBuiltinDummyConstructor  )-  , (builtinAgdaTermPi,     bindBuiltinDummyConstructor  )-  , (builtinAgdaTermSort,    bindBuiltinDummyConstructor  )-  , (builtinAgdaTermUnsupported,    bindBuiltinDummyConstructor  )-  ]+bindBuiltinInfo :: BuiltinInfo -> A.Expr -> TCM ()+bindBuiltinInfo i (A.ScopedExpr scope e) = setScope scope >> bindBuiltinInfo i e+bindBuiltinInfo (BuiltinInfo s d) e = do+    case d of+      BuiltinData t cs -> do+                           e' <- checkExpr e =<< t+                           let n = length cs+                           inductiveCheck s n e'+                           bindBuiltinName s e'+                           -- NAT and LEVEL must be different. (Why?)+                           when (s `elem` [builtinNat, builtinLevel]) $ do+                             nat   <- getBuiltin' builtinNat+                             level <- getBuiltin' builtinLevel+                             case (nat, level) of+                               (Just nat, Just level) -> do+                                  Def nat   _ <- normalise nat+                                  Def level _ <- normalise level+                                  when (nat == level) $ typeError $ GenericError $+                                    builtinNat ++ " and " ++ builtinLevel +++                                    " have to be different types."+                               _ -> return () --- | Builtin postulates-builtinPostulates :: [(String, TCM Type)]-builtinPostulates =-  [ (builtinSize,    return $ sort $ mkType 0 )-  , (builtinSizeSuc, typeOfSizeSuc            )-  , (builtinSizeInf, typeOfSizeInf            )-  ] --- | Bind a builtin constructor. Pre-condition: argument is an element of---   'builtinConstructors'.-bindConstructor :: String -> (A.Expr -> TCM Term) -> A.Expr -> TCM ()-bindConstructor s check (A.ScopedExpr scope e) = do-  setScope scope-  bindConstructor s check e-bindConstructor s check e@(A.Con _) = do-  t <- check e-  -- The constructor might have been eta expanded during type checking-  let name (Lam h b) = name (absBody b)-      name (Con c _) = Con c []-      name _         = __IMPOSSIBLE__-  bindBuiltinName s (name t)-bindConstructor s _ e               = typeError $ BuiltinMustBeConstructor s e+      BuiltinDataCons t -> do --- | Bind a builtin postulate. Pre-condition: argument is an element of---   'builtinPostulates'.-bindPostulate :: String -> TCM Type -> A.Expr -> TCM ()-bindPostulate builtin typ e = bindPostulatedName builtin e $ \q _ ->-  checkExpr (A.Def q) =<< typ+        let name (Lam h b) = name (absBody b)+            name (Con c _) = Con c []+            name _         = __IMPOSSIBLE__ +        e' <- checkExpr e =<< t++        case e of+          A.Con _ -> return ()+          _       -> typeError $ BuiltinMustBeConstructor s e++        bindBuiltinName s (name e')++      BuiltinPrim pfname axioms -> do+	case e of+	  A.Def qx -> do++            PrimImpl t pf <- lookupPrimitiveFunction pfname+            v <- checkExpr e t++            axioms v++            info <- getConstInfo qx+            let cls = defClauses info+                a   = defAbstract info+                mcc = defCompiled info+            bindPrimitive pfname $ pf { primFunName = qx }+            addConstant qx $ info { theDef = Primitive a pfname (Just cls) mcc }++            -- needed? yes, for checking equations for mul+            bindBuiltinName s v++	  _ -> typeError $ GenericError $ "Builtin " ++ s ++ " must be bound to a function"++      BuiltinPostulate t -> do+        e' <- checkExpr e =<< t+        let err = typeError $ GenericError $+                    "The argument to BUILTIN " ++ s ++ " must be a postulated name"+        case e of+          A.Def q -> do+            def <- ignoreAbstractMode $ getConstInfo q+            case theDef def of+              Axiom {} -> bindBuiltinName s e'+              _        -> err+          _ -> err++      BuiltinUnknown mt f -> do+        e' <- maybe (fst <$> inferExpr e) (checkExpr e =<<) mt+        f e'+        bindBuiltinName s e'+ -- | Bind a builtin thing to an expression. bindBuiltin :: String -> A.Expr -> TCM () bindBuiltin b e = do@@ -414,13 +381,8 @@     bind b e     where         bind b e-            | elem b builtinTypes                        = bindBuiltinType b e-            | elem b [builtinList,builtinArg]            = bindBuiltinType1 b e-            | b == builtinEquality                       = bindBuiltinEquality e-            | b == builtinInf                            = bindBuiltinInf e-            | b == builtinSharp                          = bindBuiltinSharp e-            | b == builtinFlat                           = bindBuiltinFlat e-            | Just bind  <- lookup b builtinConstructors = bindConstructor b bind e-            | Just (s,v) <- lookup b builtinPrimitives   = bindBuiltinPrimitive s b e v-            | Just typ   <- lookup b builtinPostulates   = bindPostulate b typ e-            | otherwise                                  = typeError $ NoSuchBuiltinName b+            | b == builtinInf                                   = bindBuiltinInf e+            | b == builtinSharp                                 = bindBuiltinSharp e+            | b == builtinFlat                                  = bindBuiltinFlat e+            | Just i <- find ((==b) . builtinName) coreBuiltins = bindBuiltinInfo i e+            | otherwise                                         = typeError $ NoSuchBuiltinName b

src/full/Agda/TypeChecking/Rules/Builtin/Coinduction.hs view

@@ -34,51 +34,24 @@ -- | The type of @&#x221e@.  typeOfInf :: TCM Type-typeOfInf = do-  kit <- requireLevels-  return $-    El Inf (Pi (argH $ El (Type (Lit (LitLevel noRange 0))) (levelType kit))-               (Abs "a" $ El (Type (levelSuc kit (Var 0 [])))-                             (Pi (argN $ El (Type (levelSuc kit (Var 0 [])))-                                            (Sort (Type (Var 0 []))))-                                 (Abs "A" $ El (Type (levelSuc kit (Var 1 [])))-                                               (Sort (Type (Var 1 [])))))))+typeOfInf = hPi "a" (el primLevel) $+            (return . sort $ varSort 0) --> (return . sort $ varSort 0)  -- | The type of @&#x266f_@.  typeOfSharp :: TCM Type-typeOfSharp = do-  kit <- requireLevels-  inf <- (\t -> case t of-                  Def q _ -> q-                  _       -> __IMPOSSIBLE__)-         <$> primInf-  return $-    El Inf (Pi (argH $ El (Type (Lit (LitLevel noRange 0))) (levelType kit))-               (Abs "a" $ El (Lub (Type (levelSuc kit (Var 0 []))) (Type (Var 0 [])))-                             (Pi (argH $ El (Type (levelSuc kit (Var 0 []))) (Sort (Type (Var 0 []))))-                                 (Abs "A" $ El (Type (Var 1 []))-                                               (Pi (argN $ El (Type (Var 1 [])) (Var 0 []))-                                                   (Abs "x" $ El (Type (Var 2 []))-                                                                 (Def inf [argH (Var 2 []), argN (Var 1 [])])))))))+typeOfSharp = hPi "a" (el primLevel) $+              hPi "A" (return . sort $ varSort 0) $+              (El (varSort 1) <$> var 0) -->+              (El (varSort 1) <$> primInf <#> var 1 <@> var 0)  -- | The type of @&#x266d@.  typeOfFlat :: TCM Type-typeOfFlat = do-  kit <- requireLevels-  inf <- (\t -> case t of-                  Def q _ -> q-                  _       -> __IMPOSSIBLE__)-         <$> primInf-  return $-    El Inf (Pi (argH $ El (Type (Lit (LitLevel noRange 0))) (levelType kit))-               (Abs "a" $ El (Lub (Type (levelSuc kit (Var 0 []))) (Type (Var 0 [])))-                             (Pi (argH $ El (Type (levelSuc kit (Var 0 []))) (Sort (Type (Var 0 []))))-                                 (Abs "A" $ El (Type (Var 1 []))-                                               (Fun (argN $ El (Type (Var 1 []))-                                                               (Def inf [argH (Var 1 []), argN (Var 0 [])]))-                                                    (El (Type (Var 1 [])) (Var 0 [])))))))+typeOfFlat = hPi "a" (el primLevel) $+             hPi "A" (return . sort $ varSort 0) $+             (El (varSort 1) <$> primInf <#> var 1 <@> var 0) -->+             (El (varSort 1) <$> var 0)  -- | Binds the INFINITY builtin, but does not change the type's -- definition.@@ -110,10 +83,9 @@                   , dataInduction      = CoInductive                   , dataClause         = Nothing                   , dataCons           = [sharp]-                  , dataSort           = Type (Var 1 [])+                  , dataSort           = varSort 1                   , dataPolarity       = [Invariant, Invariant]                   , dataArgOccurrences = [Unused, Positive]-                  , dataHsType         = Nothing                   , dataAbstr          = ConcreteDef                   }               }@@ -122,7 +94,6 @@                     { conPars   = 2                     , conSrcCon = sharp                     , conData   = defName infDefn-                    , conHsCode = Nothing                     , conAbstr  = ConcreteDef                     , conInd    = CoInductive                     }@@ -146,10 +117,9 @@               <$> primSharp     kit    <- requireLevels     let clause = Clause { clauseRange = noRange-                        , clauseTel   = ExtendTel (argH (El (Type (Lit (LitLevel noRange 0))) (Def (typeName kit) [])))-                                                  (Abs "a" (ExtendTel (argH (El (Type (Con (sucName kit) [argN (Var 0 [])]))-                                                                                (Sort (Type (Var 0 [])))))-                                                                      (Abs "A" (ExtendTel (argN (El (Type (Var 1 [])) (Var 0 [])))+                        , clauseTel   = ExtendTel (argH (El (mkType 0) (Def (typeName kit) [])))+                                                  (Abs "a" (ExtendTel (argH $ sort $ varSort 0)+                                                                      (Abs "A" (ExtendTel (argN (El (varSort 1) (Var 0 [])))                                                                                           (Abs "x" EmptyTel)))))                         , clausePerm  = idP 3                         , clausePats  = [ argH (VarP "a")@@ -162,10 +132,14 @@                         }     addConstant flat $       flatDefn { theDef = Function-                   { funClauses        = [Clauses Nothing clause]-                   , funCompiled       = Case 2 (Branches (Map.singleton sharp (Done 3 (Var 0 [])))-                                                          Map.empty-                                                          Nothing)+                   { funClauses        = [clause]+                   , funCompiled       =+                      let hid   = Arg Hidden Relevant+                          nohid = defaultArg in+                      Case 2 (Branches (Map.singleton sharp+                                 (Done [hid "a", hid "A", nohid "x"] (Var 0 [])))+                               Map.empty+                               Nothing)                    , funInv            = NotInjective                    , funPolarity       = [Invariant, Invariant, Invariant]                    , funArgOccurrences = [Unused, Unused, Positive]@@ -175,6 +149,7 @@                      {- flat is a projection, but in the termination checker                         it destroys the (inductive) structural ordering.                         Thus, we do not register it as a projection. -}+                   , funStatic         = False                    }                 }     return flatE

src/full/Agda/TypeChecking/Rules/Data.hs view

@@ -22,6 +22,8 @@ import Agda.TypeChecking.Polarity import Agda.TypeChecking.Free import Agda.TypeChecking.Forcing+import Agda.TypeChecking.Irrelevance+import Agda.TypeChecking.Telescope  import Agda.TypeChecking.Rules.Term ( isType_ ) @@ -43,7 +45,11 @@ checkDataDef :: Info.DefInfo -> QName -> [A.LamBinding] -> [A.Constructor] -> TCM () checkDataDef i name ps cs =     traceCall (CheckDataDef (getRange i) (qnameName name) ps cs) $ do -- TODO!! (qnameName)-	let npars = size ps+	let countPars A.DomainFree{} = 1+            countPars (A.DomainFull (A.TypedBindings _ (Arg _ _ b))) = case b of+              A.TNoBind{}   -> 1+              A.TBind _ xs _ -> size xs+            npars = sum $ map countPars ps          -- Add the datatype module         addSection (qnameToMName name) 0@@ -51,6 +57,10 @@ 	-- Look up the type of the datatype. 	t <- instantiateFull =<< typeOfConst name +        -- Make sure the shape of the type is visible+        let unTelV (TelV tel a) = telePi tel a+        t <- unTelV <$> telView t+ 	-- The parameters are in scope when checking the constructors. 	dataDef <- bindParameters ps t $ \tel t0 -> do @@ -59,7 +69,7 @@  	    -- The type we get from bindParameters is Θ -> s where Θ is the type of 	    -- the indices. We count the number of indices and return s.-            (nofIxs, s) <- splitType =<< normalise t0+            (nofIxs, s) <- splitType t0              when (any (`freeIn` s) [0..nofIxs - 1]) $ do               err <- fsep [ text "The sort of" <+> prettyTCM name@@ -73,9 +83,11 @@             reportSDoc "tc.data.sort" 20 $ vcat               [ text "checking datatype" <+> prettyTCM name               , nest 2 $ vcat-                [ text "type:   " <+> prettyTCM t0+                [ text "type (parameters instantiated):   " <+> prettyTCM t0+                , text "type (full):   " <+> prettyTCM t                 , text "sort:   " <+> prettyTCM s                 , text "indices:" <+> text (show nofIxs)+                , text "params:"  <+> text (show ps)                 ]               ] @@ -86,14 +98,13 @@                                    , dataClause         = Nothing                                    , dataCons           = []     -- Constructors are added later 				   , dataSort           = s-                                   , dataHsType         = Nothing                                    , dataAbstr          = Info.defAbstract i                                    , dataPolarity       = []                                    , dataArgOccurrences = []                                    }  	    escapeContext (size tel) $ do-	      addConstant name ( Defn Relevant name t (defaultDisplayForm name) 0 dataDef )+	      addConstant name ( Defn Relevant name t (defaultDisplayForm name) 0 noCompiledRep dataDef )  	    -- Check the types of the constructors 	    mapM_ (checkConstructor name tel' nofIxs s) cs@@ -117,7 +128,7 @@  	-- Add the datatype to the signature with its constructors. It was previously 	-- added without them.-	addConstant name (Defn Relevant name t (defaultDisplayForm name) 0 $+	addConstant name (Defn Relevant name t (defaultDisplayForm name) 0 noCompiledRep $                             dataDef { dataCons = map cname cs } 			 )         computePolarity name@@ -127,12 +138,14 @@ 	cname _			   = __IMPOSSIBLE__ -- constructors are axioms  	hideTel  EmptyTel		  = EmptyTel-	hideTel (ExtendTel (Arg _ r t) tel) = ExtendTel (Arg Hidden r t) $ hideTel <$> tel+	hideTel (ExtendTel a tel) = ExtendTel (hideAndRelParams a) $ hideTel <$> tel  	splitType (El _ (Pi _ b))  = ((+ 1) -*- id) <$> splitType (absBody b)-	splitType (El _ (Fun _ b)) = ((+ 1) -*- raise 1) <$> splitType b 	splitType (El _ (Sort s))  = return (0, s)-	splitType (El _ t)	   = typeError $ DataMustEndInSort t+	splitType a                = do+          s <- newSortMeta+          equalType a (sort s)+          return (0, s)  -- | Type check a constructor declaration. Checks that the constructor targets --   the datatype and that it fits inside the declared sort.@@ -143,19 +156,34 @@   checkConstructor d tel nofIxs s con checkConstructor d tel nofIxs s con@(A.Axiom i _ c e) =     traceCall (CheckConstructor d tel s con) $ do+{- WRONG+      -- Andreas, 2011-04-26: the following happens to the right of ':'+      -- we may use irrelevant arguments in a non-strict way in types+      t' <- workOnTypes $ do+-}+        -- check that the type of the constructor is well-formed         debugEnter c e 	t <- isType_ e+        -- check that the type of the constructor ends in the data type 	n <- size <$> getContextTelescope         debugEndsIn t d n 	constructs n t d+        -- check that the sort (universe level) of the constructor type+        -- is contained in the sort of the data type+        -- (to avoid impredicative existential types)         debugFitsIn s 	t `fitsIn` s+        -- check which constructor arguments are determined by the type ('forcing')         t' <- addForcingAnnotations t         debugAdd c t'-	escapeContext (size tel)+{-+        return t'+-}+        -- add parameters to constructor type and put into signature+        escapeContext (size tel) 	    $ addConstant c-	    $ Defn Relevant c (telePi tel t') (defaultDisplayForm c) 0-	    $ Constructor (size tel) c d Nothing (Info.defAbstract i) Inductive+	    $ Defn Relevant c (telePi tel t') (defaultDisplayForm c) 0 noCompiledRep+	    $ Constructor (size tel) c d (Info.defAbstract i) Inductive   where     debugEnter c e =       reportSDoc "tc.data.con" 5 $ vcat@@ -181,23 +209,22 @@ checkConstructor _ _ _ _ _ = __IMPOSSIBLE__ -- constructors are axioms  --- | Bind the parameters of a datatype. The bindings should be domain free.+-- | Bind the parameters of a datatype. bindParameters :: [A.LamBinding] -> Type -> (Telescope -> Type -> TCM a) -> TCM a bindParameters [] a ret = ret EmptyTel a-bindParameters (A.DomainFree h x : ps) (El _ (Pi (Arg h' Relevant a) b)) ret-    | h /= h'	=+bindParameters (A.DomainFull (A.TypedBindings _ (Arg h rel (A.TBind _ xs _))) : bs) a ret =+  bindParameters ([ A.DomainFree h rel x | x <- xs ] ++ bs) a ret+bindParameters (A.DomainFull (A.TypedBindings _ (Arg h rel (A.TNoBind _))) : bs) a ret = do+  x <- freshNoName_+  bindParameters (A.DomainFree h rel x : bs) a ret+bindParameters (A.DomainFree h rel x : ps) (El _ (Pi (Arg h' rel' a) b)) ret+  -- Andreas, 2011-04-07 ignore relevance information in binding?!+    | h /= h' = 	__IMPOSSIBLE__     | otherwise = addCtx x arg $ bindParameters ps (absBody b) $ \tel s -> 		    ret (ExtendTel arg $ Abs (show x) tel) s   where-    arg = Arg h Relevant a-bindParameters (A.DomainFree h x : ps) (El _ (Fun (Arg h' Relevant a) b)) ret-    | h /= h'	=-	__IMPOSSIBLE__-    | otherwise = addCtx x arg $ bindParameters ps (raise 1 b) $ \tel s ->-		    ret (ExtendTel arg $ Abs (show x) tel) s-  where-    arg = Arg h Relevant a+    arg = Arg h rel' a bindParameters _ _ _ = __IMPOSSIBLE__  @@ -215,11 +242,10 @@   -- The line below would be simpler, but doesn't allow datatypes   -- to be indexed by the universe level. --   noConstraints $ s' `leqSort` s-  case funView $ unEl t of-    FunV arg@(Arg h r a) _ -> do+  case unEl t of+    Pi arg@(Arg h r a) _ -> do       let s' = getSort a-      cs <- s' `leqSort` s-      addConstraints cs+      s' `leqSort` s       x <- freshName_ (argName t)       let v  = Arg h r $ Var 0 []           t' = piApply (raise 1 t) [v]@@ -232,14 +258,16 @@ constructs :: Int -> Type -> QName -> TCM () constructs nofPars t q = constrT 0 t     where+        constrT :: Nat -> Type -> TCM () 	constrT n (El s v) = constr n s v +        constr :: Nat -> Sort -> Term -> TCM () 	constr n s v = do 	    v <- reduce v 	    case v of+		Pi _ (NoAbs _ b) -> constrT n b 		Pi a b	-> underAbstraction a b $ \t -> 			   constrT (n + 1) t-		Fun _ b -> constrT n b 		Def d vs 		    | d == q -> checkParams n =<< reduce (take nofPars vs) 						    -- we only check the parameters@@ -247,17 +275,19 @@  	bad t = typeError $ ShouldEndInApplicationOfTheDatatype t -	checkParams n vs = zipWithM_ sameVar (map unArg vs) ps+	checkParams n vs = zipWithM_ sameVar vs ps 	    where 		ps = reverse [ i | (i,_) <- zip [n..] vs ] -		sameVar v i = do+		sameVar arg i+                  -- skip irrelevant parameters+                  | argRelevance arg == Irrelevant = return ()+		  | otherwise = do 		    t <- typeOfBV i-		    addConstraints =<< equalTerm t v (Var i [])-+		    equalTerm t (unArg arg) (Var i [])  -- | Force a type to be a specific datatype.-forceData :: MonadTCM tcm => QName -> Type -> tcm Type+forceData :: QName -> Type -> TCM Type forceData d (El s0 t) = liftTCM $ do     t' <- reduce t     d  <- canonicalName d@@ -266,7 +296,7 @@ 	    | d == d'   -> return $ El s0 t' 	    | otherwise	-> fail $ "wrong datatype " ++ show d ++ " != " ++ show d' 	MetaV m vs	    -> do-	    Defn _ _ t _ _ Datatype{dataSort = s} <- getConstInfo d+	    Defn {defType = t, theDef = Datatype{dataSort = s}} <- getConstInfo d 	    ps <- newArgsMeta t 	    noConstraints $ leqType (El s0 t') (El s (Def d ps)) -- TODO: need equalType? 	    reduce $ El s0 t'@@ -275,7 +305,7 @@ -- | Is the type coinductive? Returns 'Nothing' if the answer cannot -- be determined. -isCoinductive :: MonadTCM tcm => Type -> tcm (Maybe Bool)+isCoinductive :: Type -> TCM (Maybe Bool) isCoinductive t = do   El _ t <- normalise t   case t of@@ -292,9 +322,9 @@     Var   {} -> return Nothing     Lam   {} -> __IMPOSSIBLE__     Lit   {} -> __IMPOSSIBLE__+    Level {} -> __IMPOSSIBLE__     Con   {} -> __IMPOSSIBLE__     Pi    {} -> return (Just False)-    Fun   {} -> return (Just False)     Sort  {} -> return (Just False)     MetaV {} -> return Nothing-    DontCare -> __IMPOSSIBLE__+    DontCare{} -> __IMPOSSIBLE__

src/full/Agda/TypeChecking/Rules/Decl.hs view

@@ -8,6 +8,7 @@ import Data.Map (Map) import qualified Agda.Utils.IO.Locale as LocIO +import Agda.Syntax.Abstract (AnyAbstract(..)) import qualified Agda.Syntax.Abstract as A import Agda.Syntax.Internal import qualified Agda.Syntax.Info as Info@@ -25,13 +26,14 @@ import Agda.TypeChecking.Substitute import Agda.TypeChecking.Reduce import Agda.TypeChecking.SizedTypes+import Agda.TypeChecking.Telescope import Agda.TypeChecking.Forcing  import Agda.TypeChecking.Rules.Term import Agda.TypeChecking.Rules.Data    ( checkDataDef ) import Agda.TypeChecking.Rules.Record  ( checkRecDef ) import Agda.TypeChecking.Rules.Def     ( checkFunDef )-import Agda.TypeChecking.Rules.Builtin ( bindBuiltin, bindBuiltinType1 )+import Agda.TypeChecking.Rules.Builtin ( bindBuiltin )  import Agda.Compiler.HaskellTypes @@ -43,31 +45,61 @@  -- | Type check a sequence of declarations. checkDecls :: [A.Declaration] -> TCM ()-checkDecls ds = mapM_ checkDecl ds-+checkDecls ds = do+  mapM_ checkDecl ds+  -- Andreas, 2011-05-30, unfreezing moved to Interaction/Imports+  -- whenM onTopLevel unfreezeMetas  -- | Type check a single declaration. checkDecl :: A.Declaration -> TCM () checkDecl d = do-    case d of-	A.Axiom i rel x e            -> checkAxiom i rel x e-        A.Field{}                    -> typeError FieldOutsideRecord-	A.Primitive i x e	     -> checkPrimitive i x e-	A.Definition i ts ds	     -> checkMutual i ts ds-	A.Section i x tel ds	     -> checkSection i x tel ds-	A.Apply i x tel m args rd rm -> checkSectionApplication i x tel m args rd rm-	A.Import i x		     -> checkImport i x-	A.Pragma i p		     -> checkPragma i p-	A.ScopedDecl scope ds	     -> setScope scope >> checkDecls ds-        A.Open _ _                   -> return ()+    -- Issue 418 fix: freeze metas before checking an abstract things+    when isAbstract freezeMetas+    leaveTopLevelConditionally d $ case d of+	A.Axiom i rel x e        -> checkAxiom i rel x e+        A.Field{}                -> typeError FieldOutsideRecord+	A.Primitive i x e        -> checkPrimitive i x e+	A.Mutual i ds            -> checkMutual i ds+	A.Section i x tel ds     -> checkSection i x tel ds+	A.Apply i x modapp rd rm -> checkSectionApplication i x modapp rd rm+	A.Import i x             -> checkImport i x+	A.Pragma i p             -> checkPragma i p+	A.ScopedDecl scope ds    -> setScope scope >> checkDecls ds+        A.FunDef i x cs          -> check x i $ checkFunDef NotDelayed i x cs+        A.DataDef i x ps cs      -> check x i $ checkDataDef i x ps cs+        A.RecDef i x c ps tel cs -> check x i $ checkRecDef i x c ps tel cs+        A.DataSig i x ps t       -> checkAxiom i Relevant x (A.Pi (Info.ExprRange (fuseRange ps t)) ps t)+        A.RecSig i x ps t        -> checkAxiom i Relevant x (A.Pi (Info.ExprRange (fuseRange ps t)) ps t)+        A.Open _ _               -> return ()+    top <- onTopLevel+    when top $ solveSizeConstraints >> freezeMetas+    where+        unScope (A.ScopedDecl scope ds) = setScope scope >> unScope d+        unScope d = return d++        check x i m = do+          reportSDoc "tc.decl" 5 $ text "Checking" <+> prettyTCM x <> text "."+          r <- abstract (Info.defAbstract i) m+          reportSDoc "tc.decl" 5 $ text "Checked" <+> prettyTCM x <> text "."+          return r++        isAbstract = fmap Info.defAbstract (A.getDefInfo d) == Just AbstractDef++        -- Concrete definitions cannot use information about abstract things.+        abstract ConcreteDef = inConcreteMode+        abstract AbstractDef = inAbstractMode 	    -- open is just an artifact from the concrete syntax             -- retained for highlighting purposes-    solveSizeConstraints +        leaveTopLevelConditionally d =+          case d of+            A.Section{}    -> id+            A.ScopedDecl{} -> id+            _              -> leaveTopLevel  -- | Type check an axiom. checkAxiom :: Info.DefInfo -> Relevance -> QName -> A.Expr -> TCM ()-checkAxiom _ rel x e = do+checkAxiom i rel x e = do   t <- isType_ e   reportSDoc "tc.decl.ax" 10 $ sep     [ text "checked axiom"@@ -75,9 +107,10 @@     ]   -- Not safe. See Issue 330   -- t <- addForcingAnnotations t-  addConstant x (Defn rel x t (defaultDisplayForm x) 0 $ Axiom Nothing Nothing)+  addConstant x (Defn rel x t (defaultDisplayForm x) 0 noCompiledRep Axiom)   solveSizeConstraints-+  -- Andreas, 2011-05-31, that freezing below is probably wrong:+  -- when (Info.defAbstract i == AbstractDef) $ freezeMetas  -- | Type check a primitive function declaration. checkPrimitive :: Info.DefInfo -> QName -> A.Expr -> TCM ()@@ -88,7 +121,7 @@     noConstraints $ equalType t t'     let s  = show $ nameConcrete $ qnameName x     bindPrimitive s $ pf { primFunName = x }-    addConstant x (Defn Relevant x t (defaultDisplayForm x) 0 $+    addConstant x (Defn Relevant x t (defaultDisplayForm x) 0 noCompiledRep $                 Primitive (Info.defAbstract i) s Nothing Nothing)     where 	nameString (Name _ x _ _) = show x@@ -105,9 +138,6 @@             Axiom{} -> addHaskellType x hs             _       -> typeError $ GenericError                         "COMPILED_TYPE directive only works on postulates."-          -- TODO: hack-          when (hs == builtinIO) $-            bindBuiltinType1 builtinIO (A.Def x)         A.CompiledDataPragma x hs hcs -> do           def <- getConstInfo x           -- Check that the pragma appears in the same module@@ -139,8 +169,8 @@                           underPars n a = do                             a <- reduce a                             case unEl a of+                              Pi a (NoAbs _ b) -> underPars (n - 1) b                               Pi a b  -> underAbstraction a b $ underPars (n - 1)-                              Fun a b -> underPars (n - 1) b                               _       -> __IMPOSSIBLE__                       ty <- underPars np $ defType def                       reportSLn "tc.pragma.compile" 10 $ "Haskell type for " ++ show c ++ ": " ++ ty@@ -164,6 +194,14 @@               --reportSLn "tc.pragma.compile" 10 $ "Haskell type for " ++ show x ++ ": " ++ ty               addEpicCode x ep             _   -> typeError $ GenericError "COMPILED_EPIC directive only works on postulates."+        A.CompiledJSPragma x ep ->+          addJSCode x ep+        A.StaticPragma x -> do+            def <- getConstInfo x+            case theDef def of+                Function{} -> do+                    markStatic x+                _ -> typeError $ GenericError "STATIC directive only works on functions." 	A.OptionsPragma _   -> __IMPOSSIBLE__	-- not allowed here         A.EtaPragma r -> modifySignature eta           where@@ -176,11 +214,17 @@                 defs	  = sigDefinitions sig  -- | Type check a bunch of mutual inductive recursive definitions.-checkMutual :: Info.DeclInfo -> [A.TypeSignature] -> [A.Definition] -> TCM ()-checkMutual i ts ds = inMutualBlock $ do-  mapM_ checkTypeSignature ts-  mapM_ checkDefinition ds+checkMutual :: Info.DeclInfo -> [A.Declaration] -> TCM ()+checkMutual i ds = inMutualBlock $ do+  mapM_ checkDecl ds+   checkStrictlyPositive =<< currentMutualBlock+  let unScope (A.ScopedDecl _ ds) = concatMap unScope ds+      unScope d = [d]+  case concatMap unScope ds of+    -- Non-mutual definitions can be considered for projection likeness+    [A.Axiom _ _ x _, A.FunDef _ y _] | x == y -> makeProjection x+    _   -> return ()   -- | Type check the type signature of an inductive or recursive definition.@@ -192,24 +236,9 @@     case Info.defAccess i of 	PublicAccess  -> inConcreteMode $ checkAxiom i rel x e 	PrivateAccess -> inAbstractMode $ checkAxiom i rel x e+        OnlyQualified -> __IMPOSSIBLE__ checkTypeSignature _ = __IMPOSSIBLE__	-- type signatures are always axioms ---- | Check an inductive or recursive definition. Assumes the type has has been---   checked and added to the signature.-checkDefinition :: A.Definition -> TCM ()-checkDefinition d =-    case d of-	A.FunDef i x cs          -> abstract (Info.defAbstract i) $ checkFunDef NotDelayed i x cs-	A.DataDef i x ps cs      -> abstract (Info.defAbstract i) $ checkDataDef i x ps cs-	A.RecDef i x c ps tel cs -> abstract (Info.defAbstract i) $ checkRecDef i x c ps tel cs-        A.ScopedDef scope d      -> setScope scope >> checkDefinition d-    where-	-- Concrete definitions cannot use information about abstract things.-	abstract ConcreteDef = inConcreteMode-	abstract AbstractDef = inAbstractMode-- -- | Type check a module. checkSection :: Info.ModuleInfo -> ModuleName -> A.Telescope -> [A.Declaration] -> TCM () checkSection i x tel ds =@@ -230,22 +259,38 @@      check eta []             = return eta     check EmptyTel (_:_)     = bad-    check (ExtendTel (Arg h _ _) (Abs y tel)) args0@(Arg h' _ (Named name _) : args) =+    check (ExtendTel (Arg h _ _) btel) args0@(Arg h' _ (Named name _) : args) =+      let y   = absName btel+          tel = absBody btel in       case (h, h', name) of+        (Instance, NotHidden, _) -> check tel args0+        (Instance, Hidden, _) -> bad+        (Instance, Instance, Nothing) -> check tel args+        (Instance, Instance, Just x)+          | x == y                -> check tel args+          | otherwise             -> check tel args0         (Hidden, NotHidden, _)    -> check tel args0+        (Hidden, Instance, _)    -> bad         (Hidden, Hidden, Nothing) -> check tel args         (Hidden, Hidden, Just x)           | x == y                -> check tel args           | otherwise             -> check tel args0         (NotHidden, NotHidden, _) -> check tel args         (NotHidden, Hidden, _)    -> bad+        (NotHidden, Instance, _)    -> bad  -- | Check an application of a section. checkSectionApplication ::-  Info.ModuleInfo -> ModuleName -> A.Telescope -> ModuleName -> [NamedArg A.Expr] ->+  Info.ModuleInfo -> ModuleName -> A.ModuleApplication ->   Map QName QName -> Map ModuleName ModuleName -> TCM ()-checkSectionApplication i m1 ptel m2 args rd rm =-  traceCall (CheckSectionApplication (getRange i) m1 ptel m2 args) $+checkSectionApplication i m1 modapp rd rm =+  traceCall (CheckSectionApplication (getRange i) m1 modapp) $+  checkSectionApplication' i m1 modapp rd rm++checkSectionApplication' ::+  Info.ModuleInfo -> ModuleName -> A.ModuleApplication ->+  Map QName QName -> Map ModuleName ModuleName -> TCM ()+checkSectionApplication' i m1 (A.SectionApp ptel m2 args) rd rm =   checkTelescope_ ptel $ \ptel -> do   tel <- lookupSection m2   vs  <- freeVarsToApply $ qnameFromList $ mnameToList m2@@ -261,8 +306,7 @@     , nest 2 $ text "tel''=" <+> prettyTCM tel''     , nest 2 $ text "eta  =" <+> prettyTCM etaTel     ]-  (ts, cs)  <- checkArguments_ DontExpandLast (getRange i) args tel''-  noConstraints $ return cs+  ts <- noConstraints $ checkArguments_ DontExpandLast (getRange i) args tel''   reportSDoc "tc.section.apply" 20 $ vcat     [ sep [ text "applySection", prettyTCM m1, text "=", prettyTCM m2, fsep $ map prettyTCM (vs ++ ts) ]     , nest 2 $ text "  defs:" <+> text (show rd)@@ -270,6 +314,32 @@     ]   args <- instantiateFull $ vs ++ ts   applySection m1 ptel m2 args rd rm+checkSectionApplication' i m1 (A.RecordModuleIFS x) rd rm = do+  let name = mnameToQName x+  tel' <- lookupSection x+  vs <- freeVarsToApply name+  let tel = tel' `apply` vs+  case tel of+    EmptyTel -> typeError $ GenericError $ show name ++ " is not a parameterised section."+    _ -> return ()+  let telInst :: Telescope+      telInst = instFinal tel+      instFinal :: Telescope -> Telescope+      instFinal (ExtendTel _ NoAbs{}) = __IMPOSSIBLE__+      instFinal (ExtendTel (Arg h r t) (Abs n EmptyTel)) = ExtendTel (Arg Instance r t) (Abs n EmptyTel)+      instFinal (ExtendTel arg (Abs n tel)) = ExtendTel arg (Abs n (instFinal tel))+      instFinal EmptyTel = __IMPOSSIBLE__+      args = teleArgs tel+  reportSDoc "tc.section.apply" 20 $ vcat+    [ sep [ text "applySection", prettyTCM name, text "{{...}}" ]+    , nest 2 $ text "tel:" <+> prettyTCM tel+    , nest 2 $ text "telInst:" <+> prettyTCM telInst+    , nest 2 $ text "args:" <+> text (show args)+    ]++  addCtxTel telInst $ do+    vs <- freeVarsToApply name+    applySection m1 telInst x (vs ++ args) rd rm  -- | Type check an import declaration. Actually doesn't do anything, since all --   the work is done when scope checking.

src/full/Agda/TypeChecking/Rules/Decl.hs-boot view

@@ -3,12 +3,11 @@  import Data.Map           (Map) import Agda.Syntax.Info        (ModuleInfo)-import Agda.Syntax.Common      (NamedArg)-import Agda.Syntax.Abstract    (QName, Expr, Declaration, ModuleName, Telescope)+import Agda.Syntax.Abstract    (QName, Expr, Declaration, ModuleName, ModuleApplication) import Agda.TypeChecking.Monad (TCM)  checkDecls :: [Declaration] -> TCM () checkDecl  :: Declaration -> TCM () checkSectionApplication ::-  ModuleInfo -> ModuleName -> Telescope -> ModuleName -> [NamedArg Expr] ->+  ModuleInfo -> ModuleName -> ModuleApplication ->   Map QName QName -> Map ModuleName ModuleName -> TCM ()

src/full/Agda/TypeChecking/Rules/Def.hs view

@@ -3,9 +3,11 @@ module Agda.TypeChecking.Rules.Def where  import Prelude hiding (mapM)+import Control.Arrow ((***), (&&&)) import Control.Applicative import Control.Monad.State hiding (mapM) import Control.Monad.Reader hiding (mapM)+import Control.Monad.Error hiding (mapM) import Control.Monad hiding (mapM) import Data.List hiding (sort) import Data.Traversable@@ -40,9 +42,9 @@ import Agda.TypeChecking.Coverage import Agda.TypeChecking.Injectivity import Agda.TypeChecking.Polarity+import Agda.TypeChecking.Irrelevance import Agda.TypeChecking.SizedTypes-import Agda.TypeChecking.RecordPatterns-import Agda.TypeChecking.CompiledClause+import Agda.TypeChecking.CompiledClause.Compile  import Agda.TypeChecking.Rules.Term                ( checkExpr, inferExpr, checkTelescope_, isType_ ) import Agda.TypeChecking.Rules.LHS                 ( checkLeftHandSide )@@ -65,16 +67,19 @@ -- * Definitions by pattern matching --------------------------------------------------------------------------- --- | Type check a definition by pattern matching. The first argument--- specifies whether the clauses are delayed or not. checkFunDef :: Delayed -> Info.DefInfo -> QName -> [A.Clause] -> TCM ()-checkFunDef delayed i name cs =--    traceCall (CheckFunDef (getRange i) (qnameName name) cs) $ do   -- TODO!! (qnameName)+checkFunDef delayed i name cs = do         -- Get the type and relevance of the function         t    <- typeOfConst name         rel  <- relOfConst name+        checkFunDef' t rel delayed i name cs +-- | Type check a definition by pattern matching. The first argument+-- specifies whether the clauses are delayed or not.+checkFunDef' :: Type -> Relevance -> Delayed -> Info.DefInfo -> QName -> [A.Clause] -> TCM ()+checkFunDef' t rel delayed i name cs =++    traceCall (CheckFunDef (getRange i) (qnameName name) cs) $ do   -- TODO!! (qnameName)         reportSDoc "tc.def.fun" 10 $           sep [ text "checking body of" <+> prettyTCM name               , nest 2 $ text ":" <+> prettyTCM t@@ -89,12 +94,11 @@         cs <- mapM check cs          -- Check that all clauses have the same number of arguments-        unless (allEqual $ map (npats . translatedClause) cs) $-               typeError DifferentArities+        unless (allEqual $ map npats cs) $ typeError DifferentArities          reportSDoc "tc.cc" 15 $ do           sep [ text "clauses before rebindClause"-              , nest 2 $ prettyTCM (map (NamedClause name . translatedClause) cs)+              , nest 2 $ prettyTCM (map (NamedClause name) cs)               ]          -- Annotate the clauses with which arguments are actually used.@@ -106,15 +110,15 @@         -- possibly due to missing eta-contraction!?          -- Check if the function is injective-        inv <- checkInjectivity name $ map translatedClause cs+        inv <- checkInjectivity name cs          reportSDoc "tc.cc" 15 $ do           sep [ text "clauses before compilation"-              , nest 2 $ prettyTCM (map (NamedClause name . translatedClause) cs)+              , nest 2 $ prettyTCM (map (NamedClause name) cs)               ]          -- Compile the clauses-        let cc = compileClauses cs+        cc <- compileClauses True cs          reportSDoc "tc.cc" 10 $ do           sep [ text "compiled clauses of" <+> prettyTCM name@@ -122,7 +126,7 @@               ]          -- Add the definition-        addConstant name $ Defn rel name t (defaultDisplayForm name) 0+        addConstant name $ Defn rel name t (defaultDisplayForm name) 0 noCompiledRep                          $ Function                             { funClauses        = cs                             , funCompiled       = cc@@ -132,6 +136,7 @@                             , funPolarity       = []                             , funArgOccurrences = []                             , funProjection     = Nothing+                            , funStatic         = False                             }         computePolarity name         reportSDoc "tc.def.fun" 10 $ do@@ -170,10 +175,11 @@                      Type           -- type of the right hand side                      [Arg Pattern]  -- parent patterns                      Permutation    -- permutation reordering the variables in the parent pattern+                     Permutation    -- final permutation (including permutation for the parent clause)                      [A.Clause]     -- the given clauses for the with function  -- | Type check a function clause.-checkClause :: Type -> A.Clause -> TCM Clauses+checkClause :: Type -> A.Clause -> TCM Clause checkClause t c@(A.Clause (A.LHS i x aps []) rhs0 wh) =     traceCall (CheckClause t c) $     checkLeftHandSide c aps t $ \gamma delta sub xs ps t' perm -> do@@ -198,19 +204,18 @@                 A.RewriteRHS (qname:names) (eq:eqs) rhs wh -> do                      (proof,t) <- inferExpr eq                      t' <- reduce =<< instantiateFull t-                     equality <- primEquality >>= \eq -> return $ case eq of-                        Lam Hidden (Abs _ (Def equality _)) -> equality-                        Def equality _                      -> equality-                        _                                   -> __IMPOSSIBLE__+                     equality <- primEquality >>= \eq ->+                      let lamV (Lam h b) = ((h:) *** id) $ lamV (unAbs b)+                          lamV v         = ([], v) in+                      return $ case lamV eq of+                        ([Hidden, Hidden], Def equality _) -> equality+                        ([Hidden],         Def equality _) -> equality+                        ([],               Def equality _) -> equality+                        _                                  -> __IMPOSSIBLE__                      reflCon <- primRefl >>= \refl -> return $ case refl of                          Con reflCon [] -> reflCon                          _              -> __IMPOSSIBLE__                      (rewriteType,rewriteFrom,rewriteTo) <- case t' of-                         El _Set0 (Def equality' [Arg Hidden Relevant rewriteType,-                                                  Arg NotHidden Relevant rewriteFrom, Arg NotHidden Relevant rewriteTo])-                            | equality' == equality ->-                              return (rewriteType, rewriteFrom, rewriteTo)-                         -- Universe polymorphic equality                          El _Set0 (Def equality' [_level, Arg Hidden Relevant rewriteType,                                                   Arg NotHidden Relevant rewriteFrom, Arg NotHidden Relevant rewriteTo])                             | equality' == equality ->@@ -247,7 +252,7 @@                   reportSDoc "tc.with.top" 5 $                     text "TC.Rules.Def.checkclause reached A.WithRHS"                   reportSDoc "tc.with.top" 30 $-                    text (show c)+                    prettyA c                   -- Infer the types of the with expressions                   vas <- mapM inferExpr es                   (vs0, as) <- instantiateFull (unzip vas)@@ -269,25 +274,32 @@                     , text "delta2 =" <+> addCtxTel delta1 (prettyTCM delta2)                     , text "vs     =" <+> prettyTCM vs                     , text "as     =" <+> prettyTCM as+                    , text "perm'  =" <+> text (show perm')+                    , text "perm   =" <+> text (show perm)+                    , text "fPerm  =" <+> text (show finalPerm)                     ]                    -- Create the body of the original function                   ctx <- getContextTelescope                   let n    = size ctx                       m    = size delta+                      -- All the context variables                       us   = [ Arg h r (Var i []) | (i, Arg h r _) <- zip [n - 1,n - 2..0] $ telToList ctx ]+                      -- First the variables bound outside this definition                       (us0, us1') = genericSplitAt (n - m) us+                      -- Then permute the rest and grab those needed to for the with arguments                       (us1, us2)  = genericSplitAt (size delta1) $ permute perm' us1'+                      -- Now stuff the with arguments in between and finish with the remaining variables                       v    = Def aux $ us0 ++ us1 ++ (map defaultArg vs0) ++ us2                    -- We need Δ₁Δ₂ ⊢ t'-                  t' <- return $ rename (reverseP perm') t'+                  t' <- return $ renameP (reverseP perm') t'                   -- and Δ₁ ⊢ vs : as                   (vs, as) <- do                     let var = flip Var []                         -- We know that as does not depend on Δ₂                         rho = replicate (size delta2) __IMPOSSIBLE__ ++ map var [0..]-                    return $ substs rho $ rename (reverseP perm') (vs, as)+                    return $ substs rho $ renameP (reverseP perm') (vs, as)                    reportSDoc "tc.with.top" 20 $ vcat                     [ text "    with arguments" <+> prettyList (map prettyTCM vs)@@ -299,7 +311,7 @@                     , text "              body" <+> (addCtxTel delta $ prettyTCM $ mkBody v)                     ] -                  return (mkBody v, WithFunction x aux gamma delta1 delta2 vs as t' ps finalPerm cs)+                  return (mkBody v, WithFunction x aux gamma delta1 delta2 vs as t' ps perm' finalPerm cs)           in handleRHS rhs0       escapeContext (size delta) $ checkWithFunction with @@ -314,7 +326,7 @@           ]         ] -      translateRecordPatterns $+      return $         Clause { clauseRange = getRange i                , clauseTel   = killRange delta                , clausePerm  = perm@@ -326,7 +338,7 @@  checkWithFunction :: WithFunctionProblem -> TCM () checkWithFunction NoWithFunction = return ()-checkWithFunction (WithFunction f aux gamma delta1 delta2 vs as b qs perm cs) = do+checkWithFunction (WithFunction f aux gamma delta1 delta2 vs as b qs perm' perm cs) = do    reportSDoc "tc.with.top" 10 $ vcat     [ text "checkWithFunction"@@ -338,6 +350,7 @@       , text "vs     =" <+> addCtxTel delta1 (prettyTCM vs)       , text "b      =" <+> prettyTCM b       , text "qs     =" <+> text (show qs)+      , text "perm'  =" <+> text (show perm')       , text "perm   =" <+> text (show perm)       ]     ]@@ -345,7 +358,7 @@   -- Add the type of the auxiliary function to the signature    -- With display forms are closed-  df <- makeClosed <$> withDisplayForm f aux delta1 delta2 (size as) qs perm+  df <- makeClosed <$> withDisplayForm f aux delta1 delta2 (size as) qs perm'    reportSLn "tc.with.top" 20 "created with display form" @@ -361,7 +374,10 @@          , nest 2 $ prettyTCM absAuxType          ]   -- The ranges in the generated type are completely bogus, so we kill them.-  auxType <- setCurrentRange (getRange cs) $ isType_ $ killRange absAuxType+  auxType <- setCurrentRange (getRange cs) (isType_ $ killRange absAuxType)+    `catchError` \err -> case errError err of+      TypeError _ e -> enterClosure e $ traceCall (CheckWithFunctionType absAuxType) . typeError+      _             -> throwError err    case df of     OpenThing _ (Display n ts dt) -> reportSDoc "tc.with.top" 20 $ text "Display" <+> fsep@@ -369,7 +385,7 @@       , prettyList $ map prettyTCM ts       , prettyTCM dt       ]-  addConstant aux (Defn Relevant aux auxType [df] 0 $ Axiom Nothing Nothing)+  addConstant aux (Defn Relevant aux auxType [df] 0 noCompiledRep Axiom)   solveSizeConstraints    reportSDoc "tc.with.top" 10 $ sep@@ -655,7 +671,7 @@             liftIO $ LocIO.putStr $ unlines $ reverse ds -} -actualConstructor :: MonadTCM tcm => QName -> tcm QName+actualConstructor :: QName -> TCM QName actualConstructor c = do     v <- constructorForm =<< normalise (Con c [])     case v of

src/full/Agda/TypeChecking/Rules/Def.hs-boot view

@@ -1,7 +1,10 @@ module Agda.TypeChecking.Rules.Def where  import Agda.Syntax.Abstract+import Agda.Syntax.Common import Agda.Syntax.Info import Agda.TypeChecking.Monad+import qualified Agda.Syntax.Internal as I  checkFunDef :: Delayed -> DefInfo -> QName -> [Clause] -> TCM ()+checkFunDef' :: I.Type -> Relevance -> Delayed -> DefInfo -> QName -> [Clause] -> TCM ()

src/full/Agda/TypeChecking/Rules/LHS.hs view

@@ -23,8 +23,9 @@ import Agda.TypeChecking.Telescope import Agda.TypeChecking.Conversion import Agda.TypeChecking.Constraints+import Agda.TypeChecking.Irrelevance import Agda.TypeChecking.Primitive (constructorForm)-import {-# SOURCE #-} Agda.TypeChecking.Empty (isEmptyType)+import {-# SOURCE #-} Agda.TypeChecking.Empty (isReallyEmptyType) import Agda.TypeChecking.Telescope (renamingR, teleArgs)  import Agda.TypeChecking.Rules.Term (checkExpr)@@ -61,6 +62,7 @@  instance Raise AsBinding where   raiseFrom m k (AsB x v a) = uncurry (AsB x) $ raiseFrom m k (v, a)+  renameFrom m k (AsB x v a) = uncurry (AsB x) $ renameFrom m k (v, a)  instance PrettyTCM AsBinding where   prettyTCM (AsB x v a) =@@ -194,7 +196,6 @@           Primitive   {} -> __IMPOSSIBLE__       Var   {} -> return ()       Pi    {} -> return ()-      Fun   {} -> return ()       Sort  {} -> return ()       MetaV {} -> return ()       -- TODO: If the type is a meta-variable, should the test be@@ -204,11 +205,12 @@       -- error in code which has already passed the type checker.       Lam   {} -> __IMPOSSIBLE__       Lit   {} -> __IMPOSSIBLE__+      Level {} -> __IMPOSSIBLE__       Con   {} -> __IMPOSSIBLE__-      DontCare -> __IMPOSSIBLE__+      DontCare{} -> __IMPOSSIBLE__  -- | Check that a dot pattern matches it's instantiation.-checkDotPattern :: DotPatternInst -> TCM Constraints+checkDotPattern :: DotPatternInst -> TCM () checkDotPattern (DPI e v a) =   traceCall (CheckDotPattern e v) $ do   reportSDoc "tc.lhs.dot" 15 $@@ -220,7 +222,6 @@   u <- checkExpr e a   -- Should be ok to do noConstraints here   noConstraints $ equalTerm a u v-  return []  -- | Bind the variables in a left hand side. Precondition: the patterns should --   all be 'A.VarP', 'A.WildP', or 'A.ImplicitP' and the telescope should have@@ -235,7 +236,7 @@     A.WildP _     -> bindDummy (absName tel)     A.ImplicitP _ -> bindDummy (absName tel)     A.AbsurdP _   -> do-      isEmptyType $ unArg a+      isReallyEmptyType $ unArg a       bindDummy (absName tel)     _             -> __IMPOSSIBLE__     where@@ -327,8 +328,7 @@     reportSDoc "tc.lhs.top" 10 $ nest 2 $ text "type  = " <+> prettyTCM b'      -- Check dot patterns-    cs <- concat <$> mapM checkDotPattern dpi-    noConstraints $ solveConstraints cs+    mapM_ checkDotPattern dpi      let rho = renamingR perm -- I'm not certain about this...         Perm n _ = perm@@ -413,8 +413,7 @@               ]              Con c' [] <- constructorForm =<< normalise (Con c [])-            c <- return $ c' `withRangeOf` c-+            c  <- return $ c' `withRangeOf` c             ca <- defType <$> getConstInfo c              reportSDoc "tc.lhs.top" 20 $ nest 2 $ vcat@@ -423,7 +422,7 @@               ]              -- Lookup the type of the constructor at the given parameters-            a <- (`piApply` vs) . defType <$> getConstInfo c+            let a = ca `piApply` vs              -- It will end in an application of the datatype             TelV gamma' ca@(El _ (Def d' us)) <- telView a@@ -438,7 +437,7 @@ -}              -- Andreas 2010-09-07  propagate relevance info to new vars-            gamma' <- return $ fmap (\a -> a { argRelevance = rel }) gamma'+            gamma' <- return $ fmap (applyRelevance rel) gamma' {-             reportSDoc "tc.lhs.top" 20 $ nest 2 $ vcat               [ text "gamma' =" <+> text (show gamma')@@ -608,10 +607,7 @@  -- Ensures that we are not performing pattern matching on codata. -noPatternMatchingOnCodata-  :: MonadTCM tcm-  => [Arg Pattern]-  -> tcm ()+noPatternMatchingOnCodata :: [Arg Pattern] -> TCM () noPatternMatchingOnCodata = mapM_ (check . unArg)   where   check (VarP {})   = return ()

src/full/Agda/TypeChecking/Rules/LHS/Implicit.hs view

@@ -38,13 +38,14 @@   [] -> do     i <- insImp dummy tel     case i of-      Just n	-> return $ replicate n implicitP+      Just []   -> __IMPOSSIBLE__+      Just hs	-> return $ implicitPs hs       Nothing	-> return []   p : ps -> do     i <- insImp p tel     case i of-      Just 0	-> __IMPOSSIBLE__-      Just n	-> insertImplicitPatterns (replicate n implicitP ++ p : ps) tel+      Just []	-> __IMPOSSIBLE__+      Just hs	-> insertImplicitPatterns (implicitPs hs ++ p : ps) tel       Nothing	-> (p :) <$> insertImplicitPatterns ps (absBody tel')   where     dummy = defaultArg $ unnamed ()@@ -55,4 +56,5 @@       ImpInsert n    -> return $ Just n       NoInsertNeeded -> return Nothing -    implicitP = Arg Hidden Relevant . unnamed . A.ImplicitP . PatRange $ noRange+    implicitPs [] = []+    implicitPs (h : hs) = (Arg h Relevant $ unnamed $ A.ImplicitP $ PatRange $ noRange) : implicitPs hs

src/full/Agda/TypeChecking/Rules/LHS/Instantiate.hs view

@@ -25,7 +25,7 @@ -- | Instantiate a telescope with a substitution. Might reorder the telescope. --   @instantiateTel (Γ : Tel)(σ : Γ --> Γ) = Γσ~@ --   Monadic only for debugging purposes.-instantiateTel :: MonadTCM tcm => Substitution -> Telescope -> tcm (Telescope, Permutation, [Term], [Type])+instantiateTel :: Substitution -> Telescope -> TCM (Telescope, Permutation, [Term], [Type]) instantiateTel s tel = liftTCM $ do    tel <- normalise tel@@ -49,7 +49,7 @@     ]    -- s' : Substitution Γσ-  let s' = rename psR s+  let s' = renameP psR s    reportSDoc "tc.lhs.inst" 15 $ nest 2 $     text "s'   =" <+> fsep (punctuate comma $ map (maybe (text "_") prettyTCM) s')@@ -80,7 +80,16 @@     text "tel3 =" <+> brackets (fsep $ punctuate comma $ map prettyTCM tel3)    -- p : Permutation (Γσ -> Γσ~)-  let p = reorderTel tel3+  p <- case reorderTel tel3 of+    Nothing -> inContext [] $ do+      xs <- mapM freshName_ names3+      addCtxs xs (Arg NotHidden Relevant prop) $ do+        err <- sep [ text "Recursive telescope in left hand side:"+                   , fsep [ parens (prettyTCM x <+> text ":" <+> prettyTCM t)+                          | (x, t) <- zip xs tel3 ]+                   ]+        typeError $ GenericError $ show err+    Just p  -> return p    reportSLn "tc.lhs.inst" 10 $ "p   = " ++ show p

src/full/Agda/TypeChecking/Rules/LHS/Problem.hs view

@@ -41,6 +41,10 @@  type ProblemPart = Problem' () +instance Raise (Problem' p) where+  raiseFrom  m k p = p { problemTel = raiseFrom  m k $  problemTel p }+  renameFrom m k p = p { problemTel = renameFrom m k $  problemTel p }+ -- | The permutation should permute @allHoles@ of the patterns to correspond to --   the abstract patterns in the problem. type Problem	 = Problem' (Permutation, [Arg Pattern])

src/full/Agda/TypeChecking/Rules/LHS/Split.hs view

@@ -1,4 +1,4 @@-{-# LANGUAGE CPP #-}+{-# LANGUAGE CPP, PatternGuards #-}  module Agda.TypeChecking.Rules.LHS.Split where @@ -21,12 +21,15 @@ import Agda.TypeChecking.Monad import Agda.TypeChecking.Pretty import Agda.TypeChecking.Reduce+import Agda.TypeChecking.Substitute import Agda.TypeChecking.Constraints import Agda.TypeChecking.Conversion import Agda.TypeChecking.Rules.LHS.Problem import Agda.TypeChecking.Rules.Term import Agda.TypeChecking.Monad.Builtin import Agda.TypeChecking.Free+import Agda.TypeChecking.Irrelevance+import Agda.TypeChecking.MetaVars  import Agda.Utils.List import Agda.Utils.Monad@@ -76,15 +79,18 @@     splitP []	     _		  _			 = throwError $ NothingToSplit     splitP ps	    []		  EmptyTel		 = __IMPOSSIBLE__     splitP (p : ps) ((i, q) : qs) tel0@(ExtendTel a tel) = do+      let tryAgain = splitP (p : ps) ((i, q) : qs) tel0       p <- lift $ expandLitPattern p       case asView $ namedThing $ unArg p of++        -- Case: literal pattern 	(xs, p@(A.LitP lit))  -> do           -- Note that, in the presence of --without-K, this branch is           -- based on the assumption that the types of literals are           -- not indexed.            -- Andreas, 2010-09-07 cannot split on irrelevant args-          when (argRelevance a == Irrelevant) $+          when (unusableRelevance $ argRelevance a) $             typeError $ SplitOnIrrelevant p a 	  b <- lift $ litType lit 	  ok <- lift $ do@@ -98,14 +104,35 @@ 		    (fmap (LitFocus lit q i) a) 		    (fmap (Problem ps ()) tel) 	    else keepGoing++        -- Case: constructor pattern 	(xs, p@(A.ConP _ (A.AmbQ cs) args)) -> do-	  a' <- reduce $ unArg a+	  a' <- liftTCM $ reduce $ unArg a 	  case unEl a' of++            -- Type is a meta and constructor is unambiguous,+            -- in this case try to instantiate the meta.+            MetaV{} | [c] <- cs -> do+              ok <- lift $ do+                Constructor{ conData = d } <- theDef <$> getConstInfo c+                dt            <- defType <$> getConstInfo d+                vs            <- newArgsMeta dt+                El _ (Sort s) <- reduce $ apply dt vs+                (True <$ noConstraints (equalType a' (El s $ Def d vs)))+                  `catchError` \_ -> return False+              if not ok then keepGoing else+                tryAgain++            -- Subcase: split type is a Def 	    Def d vs	-> do-	      def <- theDef <$> getConstInfo d+	      def <- liftTCM $ theDef <$> getConstInfo d               unless (defIsRecord def) $-                when (argRelevance a == Irrelevant) $-                  typeError $ SplitOnIrrelevant p a+                -- cannot split on irrelevant or non-strict things+                when (unusableRelevance $ argRelevance a) $ do+                  -- Andreas, 2011-10-04 unless allowed by option+                  allowed <- liftTCM $ optExperimentalIrrelevance <$> pragmaOptions+                  unless allowed $ typeError $ SplitOnIrrelevant p a+               let mp = case def of                         Datatype{dataPars = np} -> Just np                         Record{recPars = np}    -> Just np@@ -113,7 +140,7 @@               case mp of                 Nothing -> keepGoing                 Just np ->-		  traceCall (CheckPattern p EmptyTel (unArg a)) $ do  -- TODO: wrong telescope+		  liftTCM $ traceCall (CheckPattern p EmptyTel (unArg a)) $ do  -- TODO: wrong telescope                   -- Check that we construct something in the right datatype                   c <- do                       cs' <- mapM canonicalName cs@@ -124,9 +151,13 @@                             _                       -> __IMPOSSIBLE__                       cs0 <- cons <$> getConstInfo d'                       case [ c | (c, c') <- zip cs cs', elem c' cs0 ] of-                        c : _ -> return c   -- if there are more than one they will-                                            -- all have the same canonical form+                        [c]   -> return c                         []    -> typeError $ ConstructorPatternInWrongDatatype (head cs) d+                        cs    -> -- if there are more than one we give up (they might have different types)+                          typeError $ GenericError $+                            "Can't resolve overloaded constructors targeting the same datatype (" ++ show d ++ "):" +++                            unwords (map show cs)+ 		  let (pars, ixs) = genericSplitAt np vs 		  reportSDoc "tc.lhs.split" 10 $ 		    vcat [ sep [ text "splitting on"@@ -143,7 +174,9 @@ 				 xs 				 (fmap (Focus c args (getRange p) q i d pars ixs) a) 				 (fmap (Problem ps ()) tel)+            -- Subcase: split type is not a Def 	    _	-> keepGoing+        -- Case: neither literal nor constructor pattern 	p -> keepGoing       where 	keepGoing = do@@ -151,14 +184,13 @@ 	  Split p1 xs foc p2 <- underAbstraction a tel $ \tel -> splitP ps qs tel 	  return $ Split (mappend p0 p1) xs foc p2 --- | Checks that the indices are constructors applied to distinct--- variables which do not occur free in the parameters.+-- | Checks that the indices are constructors (or literals) applied to+-- distinct variables which do not occur free in the parameters.  wellFormedIndices-  :: MonadTCM tcm-  => [Arg Term] -- ^ Parameters.+  :: [Arg Term] -- ^ Parameters.   -> [Arg Term] -- ^ Indices.-  -> tcm ()+  -> TCM () wellFormedIndices pars ixs = do   pars <- normalise pars   ixs  <- normalise ixs@@ -171,12 +203,13 @@     []          -> return ()     (v , _) : _ -> typeError $ IndexFreeInParameter v pars   where-  -- | If the term consists solely of constructors applied to-  -- variables, then the variables are returned, and otherwise-  -- nothing.+  -- | If the term consists solely of constructors (or literals)+  -- applied to variables, then the variables are returned, and+  -- otherwise nothing.   constructorApplication :: Term -> Maybe [Nat]   constructorApplication (Var x [])   = Just [x]   constructorApplication (Con c args) = constructorApplications args+  constructorApplication (Lit {})     = Just []   constructorApplication _            = Nothing    constructorApplications :: [Arg Term] -> Maybe [Nat]

src/full/Agda/TypeChecking/Rules/LHS/Unify.hs view

@@ -1,25 +1,34 @@-{-# LANGUAGE CPP, MultiParamTypeClasses, GeneralizedNewtypeDeriving #-}+{-# LANGUAGE CPP, MultiParamTypeClasses, FlexibleInstances, TupleSections,+    GeneralizedNewtypeDeriving,+    DeriveDataTypeable, DeriveFunctor, DeriveFoldable, DeriveTraversable #-}  module Agda.TypeChecking.Rules.LHS.Unify where -import Control.Applicative+import Control.Arrow ((***), (&&&))+import Control.Applicative hiding (empty) import Control.Monad.State import Control.Monad.Reader import Control.Monad.Error+import Control.Monad.Writer  import Data.Map (Map) import qualified Data.Map as Map import Data.List hiding (sort)-import Data.Traversable (traverse) +import Data.Generics (Typeable, Data)+import Data.Foldable (Foldable)+import Data.Traversable (Traversable,traverse)+ import Agda.Syntax.Common import Agda.Syntax.Internal+import Agda.Syntax.Literal import Agda.Syntax.Position  import Agda.TypeChecking.Monad import Agda.TypeChecking.Monad.Exception-import Agda.TypeChecking.Conversion+import Agda.TypeChecking.Conversion -- equalTerm import Agda.TypeChecking.Constraints+import Agda.TypeChecking.Level (reallyUnLevelView) import Agda.TypeChecking.Reduce import Agda.TypeChecking.Pretty import Agda.TypeChecking.Substitute hiding (Substitution)@@ -35,15 +44,79 @@  #include "../../../undefined.h" import Agda.Utils.Impossible+import Agda.Utils.Size -newtype Unify a = U { unUnify :: ExceptionT UnifyException (StateT UnifyState TCM) a }-  deriving (Monad, MonadIO, Functor, Applicative, MonadReader TCEnv, MonadException UnifyException)+newtype Unify a = U { unUnify :: ReaderT UnifyEnv (WriterT UnifyOutput (ExceptionT UnifyException (StateT UnifyState TCM))) a }+  deriving (Monad, MonadIO, Functor, Applicative, MonadException UnifyException, MonadWriter UnifyOutput) -data Equality = Equal Type Term Term+instance MonadReader TCEnv Unify where+  ask = U $ ReaderT $ \ _ -> ask+  local cont (U (ReaderT f)) = U $ ReaderT $ \ a -> local cont (f a)++data UnifyMayPostpone = MayPostpone | MayNotPostpone++type UnifyEnv = UnifyMayPostpone+emptyUEnv   = MayPostpone++noPostponing :: Unify a -> Unify a+noPostponing (U (ReaderT f)) = U . ReaderT . const $ f MayNotPostpone++askPostpone :: Unify UnifyMayPostpone+askPostpone = U . ReaderT $ return++-- | Output the result of unification (success or maybe).+type UnifyOutput = Unifiable++emptyUOutput :: UnifyOutput+emptyUOutput = mempty++-- | Were two terms unifiable or did we have to postpone some equation such that we are not sure?+data Unifiable+  = Definitely  -- ^ Unification succeeded.+  | Possibly    -- ^ Unification did not fail, but we had to postpone a part.++-- | Conjunctive monoid.+instance Monoid Unifiable where+  mempty = Definitely+  mappend Definitely Definitely = Definitely+  mappend _ _ = Possibly++-- | Tell that something could not be unified right now,+--   so the unification succeeds only 'Possibly'.+reportPostponing :: Unify ()+reportPostponing = tell Possibly++{-+-- | Check whether unification proceeded without postponement.+listenResult :: Unify () -> Unify UnifyOutput+listenResult m = snd <$> listen m+-}++-- | Check whether unification proceeded without postponement.+ifClean :: Unify () -> Unify a -> Unify a -> Unify a+ifClean m t e = do+  ok <- snd <$> listen m+  case ok of+    Definitely -> t+    Possibly ->   e++{-+-- | Check whether unification proceeded without postponement.+ifClean :: Unify a -> (a -> Unify b) -> (a -> Unify b) -> Unify b+ifClean m t e = do+  (ok, a) <- listen m+  case ok of+    Definitely -> t a+    Possibly ->   e a+-}++data Equality = Equal TypeHH Term Term type Sub = Map Nat Term -data UnifyException = ConstructorMismatch Type Term Term-                    | GenericUnifyException String+data UnifyException+  = ConstructorMismatch Type Term Term+  | StronglyRigidOccurrence Type Term Term+  | GenericUnifyException String  instance Error UnifyException where   noMsg  = strMsg ""@@ -58,19 +131,35 @@ constructorMismatch :: Type -> Term -> Term -> Unify a constructorMismatch a u v = throwException $ ConstructorMismatch a u v +constructorMismatchHH :: TypeHH -> Term -> Term -> Unify a+constructorMismatchHH aHH = constructorMismatch (leftHH aHH)+  -- do not report heterogenity+{-+constructorMismatchHH (Hom a) u v = constructorMismatch a u v+constructorMismatchHH (Het a1 a2) u v = constructorMismatch a1 u v+-}++{-+instance MonadReader TCEnv Unify where+  ask           = U . lift  $ ask+  local k (U m) = U . lift . lift . lift $ local k m+-}+ instance MonadState TCState Unify where-  get = U . lift . lift $ get-  put = U . lift . lift . put+  get = U . lift . lift . lift . lift $ get+  put = U . lift . lift . lift . lift . put  instance MonadTCM Unify where-  liftTCM = U . lift . lift+  liftTCM = U . lift . lift . lift . lift  instance Subst Equality where   substs us	 (Equal a s t) = Equal (substs us a)	  (substs us s)	     (substs us t)   substUnder n u (Equal a s t) = Equal (substUnder n u a) (substUnder n u s) (substUnder n u t) +{- UNUSED getSub :: Unify Sub getSub = U $ gets uniSub+-}  onSub :: (Sub -> a) -> Unify a onSub f = U $ gets $ f . uniSub@@ -79,13 +168,73 @@ modSub f = U $ modify $ \s -> s { uniSub = f $ uniSub s }  checkEqualities :: [Equality] -> TCM ()-checkEqualities eqs = noConstraints $ concat <$> mapM checkEq eqs+checkEqualities eqs = noConstraints $ mapM_ checkEq eqs   where-    checkEq (Equal a s t) = equalTerm a s t+    checkEq (Equal (Hom a) s t) = equalTerm a s t+    checkEq (Equal (Het a1 a2) s t) = typeError $ HeterogeneousEquality s a1 t a2 +-- | Force equality now instead of postponing it using 'addEquality'.+checkEquality :: Type -> Term -> Term -> TCM ()+checkEquality a u v = noConstraints $ equalTerm a u v++-- | Try equality.  If constraints remain, postpone (enter unsafe mode).+--   Heterogeneous equalities cannot be tried nor reawakened,+--   so we can throw them away and flag "dirty".+checkEqualityHH :: TypeHH -> Term -> Term -> Unify ()+checkEqualityHH (Hom a) u v = do+    ok <- liftTCM $ noConstraints (True <$ equalTerm a u v)  -- no constraints left+            `catchError` \ err -> return False+    if ok then return () else addEquality a u v+checkEqualityHH aHH@(Het a1 a2) u v = -- reportPostponing -- enter "dirty" mode+    addEqualityHH aHH u v -- postpone, enter "dirty" mode+{-+checkEqualityHH (Het a1 a2) u v = noConstraints $ do+  equalType a1 a2+  equalTerm a1 u v+-}+{-+checkEqualityHH :: MonadTCM tcm => TypeHH -> Term -> Term -> tcm ()+checkEqualityHH aHH u v = do+  a  <- forceHom aHH+  cs <- equalTerm a u v+  if null cs then return () else addEquality a u v+-}+++-- | Check whether heterogeneous situation is really homogeneous.+--   If not, give up.+forceHom :: TypeHH -> TCM Type+forceHom (Hom a) = return a+forceHom (Het a1 a2) = do+  noConstraints $ equalType a1 a2+  return a1+ addEquality :: Type -> Term -> Term -> Unify ()-addEquality a u v = U $ modify $ \s -> s { uniConstr = Equal a u v : uniConstr s }+addEquality a = addEqualityHH (Hom a) +addEqualityHH :: TypeHH -> Term -> Term -> Unify ()+addEqualityHH aHH u v = do+  reportPostponing+  U $ modify $ \s -> s { uniConstr = Equal aHH u v : uniConstr s }++{-+addEquality :: Type -> Term -> Term -> Unify ()+addEquality a u v = do+  reportPostponing+  U $ modify $ \s -> s { uniConstr = Equal a u v : uniConstr s }+-}++{-+addEquality :: Type -> Term -> Term -> Unify ()+addEquality a u v = do+   p <- askPostpone+   case p of+     MayPostpone ->  do+       reportPostponing+       U $ modify $ \s -> s { uniConstr = Equal a u v : uniConstr s }+     MayNotPostpone -> checkEquality a u v+-}+ takeEqualities :: Unify [Equality] takeEqualities = U $ do   s <- get@@ -95,16 +244,28 @@ -- | Includes flexible occurrences, metas need to be solved. TODO: relax? --   TODO: later solutions may remove flexible occurences occursCheck :: Nat -> Term -> Type -> Unify ()-occursCheck i u a-  | i `freeIn` u = do-    reportSDoc "tc.lhs.unify" 20 $ prettyTCM (Var i []) <+> text "occurs in" <+> prettyTCM u-    typeError $ UnequalTerms CmpEq (Var i []) u a-  | otherwise	 = return ()+occursCheck i u a = do+  let fv = freeVars u+      v  = Var i []+  case occurrence i fv of+    -- Andreas, 2011-04-14+    -- a strongly rigid recursive occurrences signals unsolvability+    StronglyRigid -> do+      liftTCM $ reportSDoc "tc.lhs.unify" 20 $ prettyTCM v <+> text "occurs strongly rigidly in" <+> prettyTCM u+      throwException $ StronglyRigidOccurrence a v u +    NoOccurrence  -> return ()  -- this includes irrelevant occurrences!++    -- any other recursive occurrence leads to unclear situation+    _             -> do+      liftTCM $ reportSDoc "tc.lhs.unify" 20 $ prettyTCM v <+> text "occurs in" <+> prettyTCM u+      typeError $ UnequalTerms CmpEq v u a++-- | Assignment with preceding occurs check. (|->) :: Nat -> (Term, Type) -> Unify () i |-> (u, a) = do   occursCheck i u a-  reportSDoc "tc.lhs.unify" 15 $ prettyTCM (Var i []) <+> text ":=" <+> prettyTCM u+  liftTCM $ reportSDoc "tc.lhs.unify" 15 $ prettyTCM (Var i []) <+> text ":=" <+> prettyTCM u   modSub $ Map.insert i (killRange u)  makeSubstitution :: Sub -> [Term]@@ -113,11 +274,32 @@     val i = maybe (Var i []) id $ Map.lookup i sub  -- | Apply the current substitution on a term and reduce to weak head normal form.-ureduce :: Term -> Unify Term-ureduce u = doEtaContractImplicit $ do-  rho <- onSub makeSubstitution-  liftTCM $ etaContract =<< reduce (substs rho u)+class UReduce t where+  ureduce :: t -> Unify t +instance UReduce Term where+  ureduce u = doEtaContractImplicit $ do+    rho <- onSub makeSubstitution+    liftTCM $ etaContract =<< normalise (substs rho u)+-- Andreas, 2011-06-22, fix related to issue 423+-- To make eta contraction work better, I switched reduce to normalise.+-- I hope the performance penalty is not big (since we are dealing with+-- l.h.s. terms only).+-- A systematic solution would make unification type-directed and+-- eta-insensitive...+--   liftTCM $ etaContract =<< reduce (substs rho u)++instance UReduce Type where+  ureduce (El s t) = El s <$> ureduce t++instance UReduce t => UReduce (HomHet t) where+  ureduce (Hom t)     = Hom <$> ureduce t+  ureduce (Het t1 t2) = Het <$> ureduce t1 <*> ureduce t2++instance UReduce t => UReduce (Maybe t) where+  ureduce Nothing = return Nothing+  ureduce (Just t) = Just <$> ureduce t+ -- | Take a substitution σ and ensure that no variables from the domain appear --   in the targets. The context of the targets is not changed. --   TODO: can this be expressed using makeSubstitution and substs?@@ -139,6 +321,104 @@  data UnificationResult = Unifies Substitution | NoUnify Type Term Term | DontKnow TCErr +-- | Are we in a homogeneous (one type) or heterogeneous (two types) situation?+data HomHet a+  = Hom a    -- ^ homogeneous+  | Het a a  -- ^ heterogeneous+  deriving (Typeable, Data, Show, Eq, Ord, Functor, Foldable, Traversable)++isHom :: HomHet a -> Bool+isHom Hom{} = True+isHom Het{} = False++fromHom :: HomHet a -> a+fromHom (Hom a) = a+fromHom (Het{}) = __IMPOSSIBLE__++leftHH :: HomHet a -> a+leftHH (Hom a) = a+leftHH (Het a1 a2) = a1++rightHH :: HomHet a -> a+rightHH (Hom a) = a+rightHH (Het a1 a2) = a2++instance (Raise a) => Raise (HomHet a) where+  raiseFrom n m  = fmap (raiseFrom n m)+  renameFrom n f = fmap (renameFrom n f)++instance (Subst a) => Subst (HomHet a) where+  substUnder n u = fmap (substUnder n u)+  substs us      = fmap (substs us)++instance (PrettyTCM a) => PrettyTCM (HomHet a) where+  prettyTCM (Hom a) = prettyTCM a+  prettyTCM (Het a1 a2) = prettyTCM a1 <+> text "||" <+> prettyTCM a2++type TermHH    = HomHet Term+type TypeHH    = HomHet Type+--type FunViewHH = FunV TypeHH+type TelHH     = Tele (Arg TypeHH)+type TelViewHH = TelV TypeHH++absAppHH :: SubstHH t tHH => Abs t -> TermHH -> tHH+absAppHH (Abs   _ t) u = substHH u t+absAppHH (NoAbs _ t) u = trivialHH t++class ApplyHH t where+  applyHH :: t -> HomHet Args -> HomHet t++instance ApplyHH Term where+  applyHH t = fmap (apply t)++instance ApplyHH Type where+  applyHH t = fmap (apply t)++substHH :: SubstHH t tHH => TermHH -> t -> tHH+substHH = substUnderHH 0++-- | @substHH u t@ substitutes @u@ for the 0th variable in @t@.+class SubstHH t tHH where+  substUnderHH :: Nat -> TermHH -> t -> tHH+  trivialHH    :: t -> tHH++instance (Free a, Subst a) => SubstHH (HomHet a) (HomHet a) where+  substUnderHH n (Hom u) t = fmap (substUnder n u) t+  substUnderHH n (Het u1 u2) (Hom t) =+    if n `relevantIn` t then Het (substUnder n u1 t) (substUnder n u2 t)+     else Hom (substUnder n u1 t)+  substUnderHH n (Het u1 u2) (Het t1 t2) = Het (substUnder n u1 t1) (substUnder n u2 t2)+  trivialHH = id++instance SubstHH Term (HomHet Term) where+  substUnderHH n uHH t = fmap (\ u -> substUnder n u t) uHH+  trivialHH = Hom++instance SubstHH Type (HomHet Type) where+  substUnderHH n uHH (El s t) = fmap (\ u -> El s $ substUnder n u t) uHH+-- fmap $ fmap (\ (El s v) -> El s $ substUnderHH n u v)+  -- we ignore sorts in substitution, since they do not contain+  -- terms we can match on+  trivialHH = Hom++instance SubstHH a b => SubstHH (Arg a) (Arg b) where+  substUnderHH n u = fmap $ substUnderHH n u+  trivialHH = fmap trivialHH++instance SubstHH a b => SubstHH (Abs a) (Abs b) where+  substUnderHH n u (Abs   x v) = Abs x $ substUnderHH (n + 1) u v+  substUnderHH n u (NoAbs x v) = NoAbs x $ substUnderHH n u v+  trivialHH = fmap trivialHH++instance (SubstHH a a', SubstHH b b') => SubstHH (a,b) (a',b') where+    substUnderHH n u (x,y) = (substUnderHH n u x, substUnderHH n u y)+    trivialHH = trivialHH *** trivialHH++instance SubstHH a b => SubstHH (Tele a) (Tele b) where+  substUnderHH n u  EmptyTel         = EmptyTel+  substUnderHH n u (ExtendTel t tel) = uncurry ExtendTel $ substUnderHH n u (t, tel)+  trivialHH = fmap trivialHH+ -- | Unify indices. unifyIndices_ :: MonadTCM tcm => FlexibleVars -> Type -> [Arg Term] -> [Arg Term] -> tcm Substitution unifyIndices_ flex a us vs = liftTCM $ do@@ -150,6 +430,7 @@  unifyIndices :: MonadTCM tcm => FlexibleVars -> Type -> [Arg Term] -> [Arg Term] -> tcm UnificationResult unifyIndices flex a us vs = liftTCM $ do+    a <- reduce a     reportSDoc "tc.lhs.unify" 10 $       sep [ text "unifyIndices"           , nest 2 $ text (show flex)@@ -158,13 +439,19 @@           , nest 2 $ prettyList $ map prettyTCM vs           , nest 2 $ text "context: " <+> (prettyTCM =<< getContextTelescope)           ]-    (r, USt s eqs) <- flip runStateT emptyUState . runExceptionT . unUnify $-                      unifyArgs a us vs >> recheckConstraints+    (r, USt s eqs) <- flip runStateT emptyUState . runExceptionT . runWriterT . flip runReaderT emptyUEnv . unUnify $ do+        ifClean (unifyConstructorArgs (Hom a) us vs)+          -- clean: continue unifying+          recheckConstraints+          -- dirty: just check equalities to trigger error message+          recheckEqualities      case r of-      Left (ConstructorMismatch a u v)  -> return $ NoUnify a u v-      Left (GenericUnifyException err)  -> fail err-      Right _                           -> do+      Left (ConstructorMismatch     a u v)  -> return $ NoUnify a u v+      -- Andreas 2011-04-14:+      Left (StronglyRigidOccurrence a u v)  -> return $ NoUnify a u v+      Left (GenericUnifyException     err)  -> fail err+      Right _                               -> do         checkEqualities $ substs (makeSubstitution s) eqs         let n = maximum $ (-1) : flex         return $ Unifies $ flattenSubstitution [ Map.lookup i s | i <- [0..n] ]@@ -172,30 +459,125 @@   where     flexible i = i `elem` flex +    flexibleTerm (Var i []) = flexible i+    flexibleTerm _          = False++    {- Andreas, 2011-09-12+       We unify constructors in heterogeneous situations, as long+       as the two types have the same shape (construct the same datatype).+     -}++    unifyConstructorArgs ::+         TypeHH  -- ^ The ureduced type of the constructor, instantiated to the parameters.+                 --   Possibly heterogeneous, since pars of lhs and rhs might differ.+      -> [Arg Term]  -- ^ the arguments of the constructor (lhs)+      -> [Arg Term]  -- ^ the arguments of the constructor (rhs)+      -> Unify ()+    unifyConstructorArgs a12 [] [] = return ()+    unifyConstructorArgs a12 vs1 vs2 = do+      liftTCM $ reportSDoc "tc.lhs.unify" 15 $ sep+        [ text "unifyConstructorArgs"+	-- , nest 2 $ parens (prettyTCM tel0)+	, nest 2 $ prettyList $ map prettyTCM vs1+	, nest 2 $ prettyList $ map prettyTCM vs2+        , nest 2 $ text "constructor type:" <+> prettyTCM a12+        ]+      let n = genericLength vs1+      -- since c vs1 and c vs2 have same-shaped type+      -- vs1 and vs2 must have same length+      when (n /= genericLength vs2) $ __IMPOSSIBLE__+      TelV tel12 _ <- telViewUpToHH n a12+      -- if the length of tel12 is not n, then something is wrong+      -- e.g. a12 is not a same-shaped pair of types+      when (n /= size tel12) $ __IMPOSSIBLE__+      unifyConArgs tel12 vs1 vs2++    unifyConArgs ::+         TelHH  -- ^ The telescope(s) of the constructor args    [length = n].+      -> [Arg Term]  -- ^ the arguments of the constructor (lhs) [length = n].+      -> [Arg Term]  -- ^ the arguments of the constructor (rhs) [length = n].+      -> Unify ()+    unifyConArgs _ (_ : _) [] = __IMPOSSIBLE__+    unifyConArgs _ [] (_ : _) = __IMPOSSIBLE__+    unifyConArgs _ []      [] = return ()+    unifyConArgs EmptyTel _ _ = __IMPOSSIBLE__+    unifyConArgs tel0@(ExtendTel a@(Arg _ rel bHH) tel) us0@(arg@(Arg _ _ u) : us) vs0@(Arg _ _ v : vs) = do+      liftTCM $ reportSDoc "tc.lhs.unify" 15 $ sep+        [ text "unifyConArgs"+	-- , nest 2 $ parens (prettyTCM tel0)+	, nest 2 $ prettyList $ map prettyTCM us0+	, nest 2 $ prettyList $ map prettyTCM vs0+	, nest 2 $ text "at telescope" <+> prettyTCM bHH <+> text "..."+        ]+      liftTCM $ reportSDoc "tc.lhs.unify" 25 $+        (text $ "tel0 = " ++ show tel0)+++      -- Andreas, Ulf, 2011-09-08 (AIM XVI)+      -- in case of dependent function type, we cannot postpone+      -- unification of u and v, otherwise us or vs might be ill-typed+      -- skip irrelevant parts+      uHH <- if (rel == Irrelevant) then return $ Hom u else+               ifClean (unifyHH bHH u v) (return $ Hom u) (return $ Het u v)++      liftTCM $ reportSDoc "tc.lhs.unify" 25 $+        (text "uHH (before ureduce) =" <+> prettyTCM uHH)++      uHH <- traverse ureduce uHH++      liftTCM $ reportSDoc "tc.lhs.unify" 25 $+        (text "uHH (after  ureduce) =" <+> prettyTCM uHH)++      unifyConArgs (tel `absAppHH` uHH) us vs+++{-     unifyArgs :: Type -> [Arg Term] -> [Arg Term] -> Unify ()+    unifyArgs a = unifyArgsHH (Hom a)+-}++    -- | Used for arguments of a 'Def', not 'Con'.+    unifyArgs :: Type -> [Arg Term] -> [Arg Term] -> Unify ()     unifyArgs _ (_ : _) [] = __IMPOSSIBLE__     unifyArgs _ [] (_ : _) = __IMPOSSIBLE__     unifyArgs _ [] [] = return ()     unifyArgs a us0@(arg@(Arg _ _ u) : us) vs0@(Arg _ _ v : vs) = do-      reportSDoc "tc.lhs.unify" 15 $ sep+      liftTCM $ reportSDoc "tc.lhs.unify" 15 $ sep         [ text "unifyArgs" 	, nest 2 $ parens (prettyTCM a) 	, nest 2 $ prettyList $ map prettyTCM us0 	, nest 2 $ prettyList $ map prettyTCM vs0         ]-      a <- reduce a-      case funView $ unEl a of-	FunV b _  -> do-	  unify (unArg b) u v+      a <- ureduce a  -- Q: reduce sufficient?+      case unEl a of+	Pi b _  -> do+          -- Andreas, Ulf, 2011-09-08 (AIM XVI)+          -- in case of dependent function type, we cannot postpone+          -- unification of u and v, otherwise us or vs might be ill-typed+          let dep = dependent $ unEl a+          -- skip irrelevant parts+	  unless (argRelevance b == Irrelevant) $+            (if dep then noPostponing else id) $+              unify (unArg b) u v           arg <- traverse ureduce arg 	  unifyArgs (a `piApply` [arg]) us vs 	_	  -> __IMPOSSIBLE__+      where dependent (Pi _ NoAbs{}) = False+            dependent (Pi b c)       = 0 `relevantIn` absBody c+            dependent _              = False +    -- | Check using conversion check.+    recheckEqualities :: Unify ()+    recheckEqualities = do+      eqs <- takeEqualities+      liftTCM $ checkEqualities eqs++    -- | Check using unifier.     recheckConstraints :: Unify ()     recheckConstraints = mapM_ unifyEquality =<< takeEqualities      unifyEquality :: Equality -> Unify ()-    unifyEquality (Equal a u v) = unify a u v+    unifyEquality (Equal aHH u v) = unifyHH aHH u v      i |->> x = do       i |-> x@@ -203,17 +585,151 @@      unifySizes :: Term -> Term -> Unify ()     unifySizes u v = do-      sz <- sizeType-      su <- sizeView u-      sv <- sizeView v+      sz <- liftTCM sizeType+      su <- liftTCM $ sizeView u+      sv <- liftTCM $ sizeView v       case (su, sv) of         (SizeSuc u, SizeSuc v) -> unify sz u v         (SizeSuc u, SizeInf) -> unify sz u v         (SizeInf, SizeSuc v) -> unify sz u v         _                    -> unifyAtom sz u v -    -- TODO: eta for records here+    -- | Possibly heterogeneous unification (but at same-shaped types).+    --   In het. situations, we only search for a mismatch!+    --+    -- TODO: eta for records!+    unifyHH ::+        TypeHH  -- ^ one or two types, need not be in (u)reduced form+     -> Term -> Term -> Unify ()+    unifyHH aHH u v = do+      u <- liftTCM . constructorForm =<< ureduce u+      v <- liftTCM . constructorForm =<< ureduce v+      liftTCM $ reportSDoc "tc.lhs.unify" 15 $+	sep [ text "unifyHH"+	    , nest 2 $ parens $ prettyTCM u+	    , nest 2 $ parens $ prettyTCM v+	    , nest 2 $ text ":" <+> prettyTCM aHH+	    ]+      -- obtain the (== Size) function+      isSizeName <- liftTCM isSizeNameTest++      -- check whether types have the same shape+      (aHH, sh) <- shapeViewHH =<< ureduce aHH+      case sh of+        ElseSh  -> checkEqualityHH aHH u v -- not a type or not same types++        DefSh d -> if isSizeName d then unifySizes u v+                                   else unifyAtomHH aHH u v+        _ -> unifyAtomHH aHH u v++    unifyAtomHH ::+         TypeHH -- ^ in ureduced form+      -> Term -> Term -> Unify ()+    unifyAtomHH aHH0 u v = do+      let (aHH, homogeneous, a) = case aHH0 of+            Hom a                -> (aHH0, True, a)+            Het a1 a2 | a1 == a2 -> (Hom a1, True, a1) -- BRITTLE: just checking syn.eq.+            _                    -> (aHH0, False, __IMPOSSIBLE__)+           -- use @a@ only if 'homogeneous' holds!++          fallback = checkEqualityHH aHH u v++      liftTCM $ reportSDoc "tc.lhs.unify" 15 $+	sep [ text "unifyAtom"+	    , nest 2 $ prettyTCM u <> if flexibleTerm u then text " (flexible)" else empty+            , nest 2 $ text "=?="+	    , nest 2 $ prettyTCM v <> if flexibleTerm v then text " (flexible)" else empty+	    , nest 2 $ text ":" <+> prettyTCM aHH+	    ]+      case (u, v) of+        -- Ulf, 2011-06-19+        -- We don't want to worry about levels here.+        (Level l, v) -> do+            u <- liftTCM $ reallyUnLevelView l+            unifyAtomHH aHH u v+        (u, Level l) -> do+            v <- liftTCM $ reallyUnLevelView l+            unifyAtomHH aHH u v+	(Var i us, Var j vs) | i == j  -> checkEqualityHH aHH u v+	(Var i [], v) | homogeneous && flexible i -> i |->> (v, a)+	(u, Var j []) | homogeneous && flexible j -> j |->> (u, a)+	(Con c us, Con c' vs)+          | c == c' -> do+              r <- ureduce =<< liftTCM (dataOrRecordTypeHH c aHH)+              case r of+                Just a'HH -> unifyConstructorArgs a'HH us vs+                Nothing   -> checkEqualityHH aHH u v+          | otherwise -> constructorMismatchHH aHH u v+        -- Definitions are ok as long as they can't reduce (i.e. datatypes/axioms)+	(Def d us, Def d' vs)+          | d == d' -> do+              -- d must be a data, record or axiom+              def <- getConstInfo d+              let ok = case theDef def of+                    Datatype{} -> True+                    Record{}   -> True+                    Axiom{}    -> True+                    _          -> False+              inj <- liftTCM $ optInjectiveTypeConstructors <$> pragmaOptions+              if inj && ok+                then unifyArgs (defType def) us vs+                else checkEqualityHH aHH u v+          -- Andreas, 2011-05-30: if heads disagree, abort+          -- but do not raise "mismatch" because otherwise type constructors+          -- would be distinct+          | otherwise -> checkEqualityHH aHH u v -- typeError $ UnequalTerms CmpEq u v a+        (Lit l1, Lit l2)+          | l1 == l2  -> return ()+          | otherwise -> constructorMismatchHH aHH u v++        -- We can instantiate metas if the other term is inert (constructor application)+        -- Andreas, 2011-09-13: test/succeed/IndexInference needs this feature.+        (MetaV m us, v) | homogeneous -> do+            ok <- liftTCM $ instMeta a m us v+            liftTCM $ reportSDoc "tc.lhs.unify" 40 $+              vcat [ fsep [ text "inst meta", text $ if ok then "(ok)" else "(not ok)" ]+                   , nest 2 $ sep [ prettyTCM u, text ":=", prettyTCM =<< normalise u ]+                   ]+            if ok then unify a u v+                  else addEquality a u v+        (u, MetaV m vs) | homogeneous -> do+            ok <- liftTCM $ instMeta a m vs u+            liftTCM $ reportSDoc "tc.lhs.unify" 40 $+              vcat [ fsep [ text "inst meta", text $ if ok then "(ok)" else "(not ok)" ]+                   , nest 2 $ sep [ prettyTCM v, text ":=", prettyTCM =<< normalise v ]+                   ]+            if ok then unify a u v+                  else addEquality a u v++	(Con c us, _) -> do+           md <- isEtaRecordTypeHH aHH+           case md of+             Just (d, parsHH) -> do+               (tel, vs) <- liftTCM $ etaExpandRecord d (rightHH parsHH) v+               b <- liftTCM $ getRecordConstructorType d+               bHH <- ureduce (b `applyHH` parsHH)+               unifyConstructorArgs bHH us vs+             Nothing -> fallback++	(_, Con c vs) -> do+           md <- isEtaRecordTypeHH aHH+           case md of+             Just (d, parsHH) -> do+               (tel, us) <- liftTCM $ etaExpandRecord d (leftHH parsHH) u+               b <- liftTCM $ getRecordConstructorType d+               bHH <- ureduce (b `applyHH` parsHH)+               unifyConstructorArgs bHH us vs+             Nothing -> fallback++        -- Andreas, 2011-05-30: If I put checkEquality below, then Issue81 fails+        -- because there are definitions blocked by flexibles that need postponement+	_  -> fallback++     unify :: Type -> Term -> Term -> Unify ()+    unify a = unifyHH (Hom a)+{-+    unify :: Type -> Term -> Term -> Unify ()     unify a u v = do       u <- constructorForm =<< ureduce u       v <- constructorForm =<< ureduce v@@ -226,11 +742,33 @@       isSize <- isSizeType a       if isSize then unifySizes u v                 else unifyAtom a u v+-}      unifyAtom :: Type -> Term -> Term -> Unify ()-    unifyAtom a u v =+    unifyAtom a = unifyAtomHH (Hom a)++{-+    unifyAtom :: Type -> Term -> Term -> Unify ()+    unifyAtom a u v = do+      reportSDoc "tc.lhs.unify" 15 $+	sep [ text "unifyAtom"+	    , nest 2 $ prettyTCM u <> if flexibleTerm u then text " (flexible)" else empty+            , nest 2 $ text "=?="+	    , nest 2 $ prettyTCM v <> if flexibleTerm v then text " (flexible)" else empty+	    , nest 2 $ text ":" <+> prettyTCM a+	    ]       case (u, v) of-	(Var i us, Var j vs) | i == j  -> addEquality a u v+        -- Ulf, 2011-06-19+        -- We don't want to worry about levels here.+        (Level l, v) -> do+            u <- liftTCM $ reallyUnLevelView l+            unifyAtom a u v+        (u, Level l) -> do+            v <- liftTCM $ reallyUnLevelView l+            unifyAtom a u v+        -- Andreas, 2011-05-30+        -- Force equality now rather than postponing it with addEquality+	(Var i us, Var j vs) | i == j  -> checkEquality a u v 	(Var i [], v) | flexible i -> i |->> (v, a) 	(u, Var j []) | flexible j -> j |->> (u, a) 	(Con c us, Con c' vs)@@ -252,6 +790,17 @@               if inj && ok                 then unifyArgs (defType def) us vs                 else addEquality a u v+{- Andreas: checkEquality breaks Data.Vec.Equality+   we need an injectivity test for data types, Vec A n is injective!+                else checkEquality a u v+                -- Andreas: force equality now instead of postponing+                -- We do not want to end up in a heterogeneous situation,+                -- where u and v have different types+-}+          -- Andreas, 2011-05-30: if heads disagree, abort+          -- but do not raise "mismatch" because otherwise type constructors+          -- would be distinct+          | otherwise -> typeError $ UnequalTerms CmpEq u v a         (Lit l1, Lit l2)           | l1 == l2  -> return ()           | otherwise -> constructorMismatch a u v@@ -273,8 +822,10 @@                    ]             if ok then unify a u v                   else addEquality a u v+        -- Andreas, 2011-05-30: If I put checkEquality below, then Issue81 fails+        -- because there are definitions blocked by flexibles that need postponement 	_  -> addEquality a u v-+-}     -- The contexts are transient when unifying, so we should just instantiate to     -- constructor heads and generate fresh metas for the arguments. Beware of     -- constructors that aren't fully applied.@@ -301,16 +852,19 @@                 tel <- getContextTelescope                 -- important: create the meta in the same environment as the original meta                 newArgsMetaCtx b' tel us-            noConstraints $ assignV a m us (v' `apply` margs)+            noConstraints $ assignV m us (v' `apply` margs)             return True           `catchError` \_ -> return False      inertApplication :: Type -> Term -> TCM (Maybe (Term, Type, Args))     inertApplication a v =       case v of+        Con c vs -> fmap (\ b -> (Con c [], b, vs)) <$> dataOrRecordType c a+{-         Con c vs -> do           b <- dataOrRecordType c a           return $ Just (Con c [], b, vs)+-}         Def d vs -> do           def <- getConstInfo d           let ans = Just (Def d [], defType def, vs)@@ -327,16 +881,157 @@ -- -- Precondition: The type has to correspond to an application of the -- given constructor.+dataOrRecordType+  :: QName -- ^ Constructor name.+  -> Type  -- ^ Type of constructor application (must end in data/record).+  -> TCM (Maybe Type) -- ^ Type of constructor, applied to pars.+dataOrRecordType c a = fmap (\ (d, b, args) -> b `apply` args) <$> dataOrRecordType' c a +dataOrRecordType' ::+     QName -- ^ Constructor name.+  -> Type  -- ^ Type of constructor application (must end in data/record).+  -> TCM (Maybe (QName, Type, Args))+           -- ^ Name of data/record type,+           --   type of constructor to be applied, and+           --   data/record parameters+dataOrRecordType' c a = do+  -- The telescope ends with a datatype or a record.+  TelV _ (El _ (Def d args)) <- telView a+  def <- theDef <$> getConstInfo d+  r <- case def of+    Datatype{dataPars = n} -> Just . ((,) n) . defType <$> getConstInfo c+    Record  {recPars  = n} -> Just . ((,) n) <$> getRecordConstructorType d+    _		           -> return Nothing+  return $ fmap (\ (n, a') -> (d, a', genericTake n args)) r++-- | Heterogeneous situation.+--   @a1@ and @a2@ need to end in same datatype/record.+dataOrRecordTypeHH ::+     QName      -- ^ Constructor name.+  -> TypeHH     -- ^ Type(s) of constructor application (must end in same data/record).+  -> TCM (Maybe TypeHH) -- ^ Type of constructor, instantiated possibly heterogeneously to parameters.+dataOrRecordTypeHH c (Hom a) = fmap Hom <$> dataOrRecordType c a+dataOrRecordTypeHH c (Het a1 a2) = do+  r1 <- dataOrRecordType' c a1+  r2 <- dataOrRecordType' c a2  -- b2 may have different parameters than b1!+  return $ case (r1, r2) of+    (Just (d1, b1, pars1), Just (d2, b2, pars2)) | d1 == d2 -> Just $+        -- Andreas, 2011-09-15 if no parameters, we can stay homogeneous+        if null pars1 && null pars2 then Hom b1+         -- if parameters, go heterogeneous+         -- TODO: make this smarter, because parameters could be equal!+         else Het (b1 `apply` pars1) (b2 `apply` pars2)+    _ -> Nothing++-- | Return record type identifier if argument is a record type.+isEtaRecordTypeHH :: MonadTCM tcm => TypeHH -> tcm (Maybe (QName, HomHet Args))+isEtaRecordTypeHH (Hom a) = fmap (\ (d, ps) -> (d, Hom ps)) <$> liftTCM (isEtaRecordType a)+isEtaRecordTypeHH (Het a1 a2) = do+  m1 <- liftTCM $ isEtaRecordType a1+  m2 <- liftTCM $ isEtaRecordType a2+  case (m1, m2) of+    (Just (d1, as1), Just (d2, as2)) | d1 == d2 -> return $ Just (d1, Het as1 as2)+    _ -> return Nothing+++{- dataOrRecordType :: MonadTCM tcm-                 => QName -- ^ Constructor name.-                 -> Type -> tcm Type-dataOrRecordType c a = do+  => QName -- ^ Constructor name.+  -> Type  -- ^ Type of constructor application (must end in data/record).+  -> tcm (Maybe Type) -- ^ Type of constructor, applied to pars.+dataOrRecordType c a = fmap snd <$> dataOrRecordType' c a++dataOrRecordType' :: MonadTCM tcm+  => QName -- ^ Constructor name.+  -> Type  -- ^ Type of constructor application (must end in data/record).+  -> tcm (Maybe (QName, -- ^ Name of data/record type.+                 Type))  -- ^ Type of constructor, applied to pars.+dataOrRecordType' c a = do   -- The telescope ends with a datatype or a record.   TelV _ (El _ (Def d args)) <- telView a   def <- theDef <$> getConstInfo d-  (n, a')  <- case def of-    Datatype{dataPars = n} -> ((,) n) . defType <$> getConstInfo c-    Record  {recPars  = n} -> ((,) n) <$> getRecordConstructorType d-    _		           -> __IMPOSSIBLE__-  return (a' `apply` genericTake n args)+  r <- case def of+    Datatype{dataPars = n} -> Just . ((,) n) . defType <$> getConstInfo c+    Record  {recPars  = n} -> Just . ((,) n) <$> getRecordConstructorType d+    _		           -> return Nothing+  return $ fmap (\ (n, a') -> (d, a' `apply` genericTake n args)) r++-- | Heterogeneous situation.+--   @a1@ and @a2@ need to end in same datatype/record.+dataOrRecordTypeHH :: MonadTCM tcm+  => QName      -- ^ Constructor name.+  -> TypeHH     -- ^ Type(s) of constructor application (must end in same data/record).+  -> tcm (Maybe TypeHH) -- ^ Type of constructor, instantiated possibly heterogeneously to parameters.+dataOrRecordTypeHH c (Hom a) = fmap Hom <$> dataOrRecordType c a+dataOrRecordTypeHH c (Het a1 a2) = do+  r1 <- dataOrRecordType' c a1+  r2 <- dataOrRecordType' c a2  -- b2 may have different parameters than b1!+  return $ case (r1, r2) of+    (Just (d1, b1), Just (d2, b2)) | d1 == d2 -> Just $ Het b1 b2+    _ -> Nothing+-}++-- | Views an expression (pair) as type shape.  Fails if not same shape.+data ShapeView a+  = PiSh (Arg a) (Abs a)+  | FunSh (Arg a) a+  | DefSh QName   -- ^ data/record+  | VarSh Nat     -- ^ neutral type+  | LitSh Literal -- ^ built-in type+  | SortSh+  | MetaSh        -- ^ some meta+  | ElseSh        -- ^ not a type or not definitely same shape+  deriving (Typeable, Data, Show, Eq, Ord, Functor)++-- | Return the type and its shape.  Expects input in (u)reduced form.+shapeView :: Type -> Unify (Type, ShapeView Type)+shapeView t = do+--  t <- liftTCM $ reduce t  -- DO NOT REDUCE!+-- --  t <- ureduce t  -- BUG!! substitutes bound variables in telescope!+  return . (t,) $ case unEl t of+    Pi a (NoAbs _ b) -> FunSh a b+    Pi a (Abs x b) -> PiSh a (Abs x b)+    Def d vs       -> DefSh d+    Var x vs       -> VarSh x+    Lit l          -> LitSh l+    Sort s         -> SortSh+    MetaV m vs     -> MetaSh+    _              -> ElseSh++-- | Return the reduced type(s) and the common shape.+shapeViewHH :: TypeHH -> Unify (TypeHH, ShapeView TypeHH)+shapeViewHH (Hom a) = do+  (a, sh) <- shapeView a+  return (Hom a, fmap Hom sh)+shapeViewHH (Het a1 a2) = do+  (a1, sh1) <- shapeView a1+  (a2, sh2) <- shapeView a2+  return . (Het a1 a2,) $ case (sh1, sh2) of++    (PiSh (Arg h1 r1 a1) b1, PiSh (Arg h2 r2 a2) b2)+      | h1 == h2 ->+      PiSh (Arg h1 (min r1 r2) (Het a1 a2)) (Abs (absName b1) (Het (absBody b1) (absBody b2)))++    (FunSh (Arg h1 r1 a1) b1, FunSh (Arg h2 r2 a2) b2)+      | h1 == h2 ->+      FunSh (Arg h1 (min r1 r2) (Het a1 a2)) (Het b1 b2)++    (DefSh d1, DefSh d2) | d1 == d2 -> DefSh d1+    (VarSh x1, VarSh x2) | x1 == x2 -> VarSh x1+    (LitSh l1, LitSh l2) | l1 == l2 -> LitSh l1+    (SortSh, SortSh)                -> SortSh+    _ -> ElseSh  -- not types, or metas, or not same shape+++-- | @telViewUpToHH n t@ takes off the first @n@ function types of @t@.+-- Takes off all if $n < 0$.+telViewUpToHH :: Int -> TypeHH -> Unify TelViewHH+telViewUpToHH 0 t = return $ TelV EmptyTel t+telViewUpToHH n t = do+  (t, sh) <- shapeViewHH =<< liftTCM (traverse reduce t)+  case sh of+    PiSh a b  -> absV a (absName b) <$> telViewUpToHH (n-1) (absBody b)+    FunSh a b -> absV a "_" <$> telViewUpToHH (n-1) (raise 1 b)+    _         -> return $ TelV EmptyTel t+  where+    absV a x (TelV tel t) = TelV (ExtendTel a (Abs x tel)) t

src/full/Agda/TypeChecking/Rules/Record.hs view

@@ -17,7 +17,8 @@ import Agda.TypeChecking.Reduce import Agda.TypeChecking.Pretty import Agda.TypeChecking.Polarity-import Agda.TypeChecking.CompiledClause+import Agda.TypeChecking.Irrelevance+import Agda.TypeChecking.CompiledClause.Compile  import Agda.TypeChecking.Rules.Data ( bindParameters, fitsIn ) import Agda.TypeChecking.Rules.Term ( isType_ )@@ -33,7 +34,19 @@ -- * Records --------------------------------------------------------------------------- -checkRecDef :: Info.DefInfo -> QName -> Maybe A.Constructor ->+-- | @checkRecDef i name con ps contel fields@+--+--     [@name@]    Record type identifier.+--+--     [@con@]     Maybe constructor name and info.+--+--     [@ps@]      Record parameters.+--+--     [@contel@]  Approximate type of constructor (@fields@ -> Set).+--+--     [@fields@]  List of field signatures.+--+checkRecDef :: Info.DefInfo -> QName -> Maybe A.QName -> --Maybe A.Constructor ->                [A.LamBinding] -> A.Expr -> [A.Constructor] -> TCM () checkRecDef i name con ps contel fields =   traceCall (CheckRecDef (getRange i) (qnameName name) ps fields) $ do@@ -41,49 +54,76 @@       [ text "checking record def" <+> prettyTCM name       , nest 2 $ text "ps ="     <+> prettyList (map prettyA ps)       , nest 2 $ text "contel =" <+> prettyA contel-      , nest 2 $ text "fields =" <+> prettyA fields+      , nest 2 $ text "fields =" <+> prettyA (map Constr fields)       ]     -- get type of record     t <- instantiateFull =<< typeOfConst name     bindParameters ps t $ \tel t0 -> do++      -- Generate type of constructor from field telescope @contel@,+      -- which is the approximate constructor type (target missing).++      -- Check and evaluate field types.+      reportSDoc "tc.rec" 15 $ text "checking fields"+      -- WRONG: contype <- workOnTypes $ killRange <$> (instantiateFull =<< isType_ contel)+      contype <- killRange <$> (instantiateFull =<< isType_ contel)++      -- compute the field telescope+      let TelV ftel _ = telView' contype++          -- A record is irrelevant if all of its fields are.+          -- In this case, the associated module parameter will be irrelevant.+          -- See issue 392.+          recordRelevance = minimum $ Irrelevant : (map argRelevance $ telToList ftel)++      -- Compute correct type of constructor+       -- t = tel -> t0 where t0 must be a sort s       t0' <- normalise t0       s <- case unEl t0' of 	Sort s	-> return s 	_	-> typeError $ ShouldBeASort t0       gamma <- getContextTelescope-      let m = qnameToMName name-	  htel		 = map hide $ telToList tel-	  rect		 = El s $ Def name $ reverse-			   [ Arg h r (Var i [])-			   | (i, Arg h r _) <- zip [0..] $ reverse $ telToList gamma-			   ]-	  tel'		 = telFromList $ htel ++ [defaultArg ("r", rect)]-          extWithR ret   = underAbstraction (defaultArg rect) (Abs "r" ()) $ \_ -> ret-          ext (Arg h r (x, t)) = addCtx x (Arg h r t)--      let getName :: A.Declaration -> [Arg QName]-          getName (A.Field _ x arg)    = [fmap (const x) arg]-	  getName (A.ScopedDecl _ [f]) = getName f-	  getName _		       = []--      ctx <- (reverse . map hide . take (size tel)) <$> getContext+      let m               = qnameToMName name+          -- make record parameters hidden and non-stricts irrelevant+	  htel		  = map hideAndRelParams $ telToList tel+          -- record type (name applied to parameters)+	  rect		  = El s $ Def name $ reverse+			    [ Arg h r (Var i [])+			    | (i, Arg h r _) <- zip [0..] $ reverse $ telToList gamma+			    ]+	  telh' h	  = telFromList $ htel ++ [Arg h recordRelevance ("r", rect)]+	  tel'		  = telh' NotHidden+	  telIFS	  = telh' Instance+          extWithRH h ret = underAbstraction (Arg h recordRelevance rect) (Abs "" ()) $ \_ -> ret+          extWithR        = extWithRH NotHidden+          ext     (Arg h r (x, t)) = addCtx x (Arg h r t)+{- UNUSED+          extHide (Arg h r (x, t)) = addCtx x (Arg Hidden r t)+-} -      -- We have to rebind the parameters to make them hidden-      -- Check the field telescope-      contype <- killRange <$> (instantiateFull =<< isType_ contel)-      let TelV ftel _ = telView' contype-      let contype = telePi ftel (raise (size ftel) rect)+      -- Put in @rect@ as correct target of constructor type.+      -- Andreas, 2011-05-10 use telePi_ instead of telePi to preserve+      -- even names of non-dependent fields in constructor type (Issue 322).+      let contype = telePi_ ftel (raise (size ftel) rect) +      -- Obtain name of constructor (if present).       (hasNamedCon, conName, conInfo) <- case con of-        Just (A.Axiom i _ c _) -> return (True, c, i)-        Just _                 -> __IMPOSSIBLE__-        Nothing                -> do+        Just c  -> return (True, c, i)+        Nothing -> do           m <- killRange <$> currentModule           c <- qualify m <$> freshName_ "recCon-NOT-PRINTED"           return (False, c, i) -      addConstant name $ Defn Relevant name t0 (defaultDisplayForm name) 0+      -- Add record type to signature.+      reportSDoc "tc.rec" 15 $ text "adding record type to signature"++      let getName :: A.Declaration -> [Arg QName]+          getName (A.Field _ x arg)    = [fmap (const x) arg]+	  getName (A.ScopedDecl _ [f]) = getName f+	  getName _		       = []++      addConstant name $ Defn Relevant name t0 (defaultDisplayForm name) 0 noCompiledRep 		       $ Record { recPars           = 0                                 , recClause         = Nothing                                 , recCon            = conName@@ -97,21 +137,37 @@                                 , recArgOccurrences = []                                 } +      -- Add record constructor to signature+      -- Andreas, 2011-05-19 moved this here, it was below the record module+      --   creation       addConstant conName $-        Defn Relevant conName contype (defaultDisplayForm conName) 0 $+        Defn Relevant conName contype (defaultDisplayForm conName) 0 noCompiledRep $              Constructor { conPars   = 0                          , conSrcCon = conName                          , conData   = name-                         , conHsCode = Nothing                          , conAbstr  = Info.defAbstract conInfo                          , conInd    = Inductive                          } +      -- Check that the fields fit inside the sort+      let dummy = Var 0 []  -- We're only interested in the sort here+      telePi ftel (El s dummy) `fitsIn` s++      {- Andreas, 2011-04-27 WRONG because field types are checked again+         and then non-stricts should not yet be irrelevant++      -- make record parameters hidden and non-stricts irrelevant+      -- ctx <- (reverse . map hideAndRelParams . take (size tel)) <$> getContext+      -}++      -- make record parameters hidden+      ctx <- (reverse . map hide . take (size tel)) <$> getContext+       escapeContext (size tel) $ flip (foldr ext) ctx $ extWithR $ do 	reportSDoc "tc.rec.def" 10 $ sep 	  [ text "record section:" 	  , nest 2 $ sep-            [ prettyTCM m <+> (prettyTCM =<< getContextTelescope)+            [ prettyTCM m <+> (inContext [] . prettyTCM =<< getContextTelescope)             , fsep $ punctuate comma $ map (text . show . getName) fields             ] 	  ]@@ -123,30 +179,32 @@         -- Check the types of the fields         -- ftel <- checkRecordFields m name tel s [] (size fields) fields         withCurrentModule m $-          checkRecordProjections m conName tel' (raise 1 ftel) fields+          checkRecordProjections m name conName tel' (raise 1 ftel) fields -      -- Check that the fields fit inside the sort-      let dummy = Var 0 []  -- We're only interested in the sort here-      telePi ftel (El s dummy) `fitsIn` s+      -- Andreas, 2011-05-19 here was the code "Add record constr..."        computePolarity name        return () -{-| @checkRecordProjections q tel ftel s vs n fs@:-    @m@: name of the generated module-    @q@: name of the record-    @tel@: parameters-    @s@: sort of the record-    @ftel@: telescope of fields-    @vs@: values of previous fields (should have one free variable, which is-	  the record)-    @fs@: the fields to be checked+{-| @checkRecordProjections m r q tel ftel fs@.++    [@m@    ]  name of the generated module++    [@r@    ]  name of the record type++    [@q@    ]  name of the record constructor++    [@tel@  ]  parameters++    [@ftel@ ]  telescope of fields++    [@fs@   ]  the fields to be checked -} checkRecordProjections ::-  ModuleName -> QName -> Telescope -> Telescope ->+  ModuleName -> QName -> QName -> Telescope -> Telescope ->   [A.Declaration] -> TCM ()-checkRecordProjections m q tel ftel fs = checkProjs EmptyTel ftel fs+checkRecordProjections m r q tel ftel fs = checkProjs EmptyTel ftel fs   where      checkProjs :: Telescope -> Telescope -> [A.Declaration] -> TCM ()@@ -162,15 +220,16 @@       reportSDoc "tc.rec.proj" 5 $ sep 	[ text "checking projection" 	, nest 2 $ vcat-	  [ text "top   =" <+> (prettyTCM =<< getContextTelescope)+	  [ text "top   =" <+> (inContext [] . prettyTCM =<< getContextTelescope) 	  , text "ftel1 =" <+> prettyTCM ftel1 	  , text "ftel2 =" <+> addCtxTel ftel1 (underAbstraction_ ftel2 prettyTCM) 	  , text "t     =" <+> prettyTCM t 	  ] 	]+      -- Andreas, 2011-04-27 work on rhs of ':'+      -- WRONG: t <- workOnTypes $ isType_ t       t <- isType_ t -       -- Andreas, 2010-09-09 The following comments are misleading, TODO: update       -- in fact, tel includes the variable of record type as last one       -- e.g. for cartesion product it is@@ -197,17 +256,19 @@        reportSDoc "tc.rec.proj" 10 $ sep 	[ text "adding projection"-	, nest 2 $ prettyTCM projname <+> text ":" <+> prettyTCM finalt+	, nest 2 $ prettyTCM projname <+> text ":" <+> inContext [] (prettyTCM finalt) 	]        -- The body should be       --  P.xi {tel} (r _ .. x .. _) = x+      -- Ulf, 2011-08-22: actually we're dropping the parameters from the+      -- projection functions so the body is now+      --  P.xi (r _ .. x .. _) = x        let -- Andreas, 2010-09-09: comment for existing code           -- split the telescope into parameters (ptel) and the type or the record           -- (rt) which should be  R ptel           (ptel,[rt]) = splitAt (size tel - 1) $ telToList tel-          hps	 = map (fmap $ VarP . fst) $ ptel 	  conp	 = defaultArg 		 $ ConP q (Just (fmap snd rt))                    $ zipWith3 Arg@@ -216,37 +277,42 @@ 			      [ VarP "x" | _ <- [1..size ftel] ] 	  nobind 0 = id 	  nobind n = Bind . Abs "_" . nobind (n - 1)-	  body	 = nobind (size ptel)-		 $ nobind (size ftel1)+	  body	 = nobind (size ftel1) 		 $ Bind . Abs "x" 		 $ nobind (size ftel2) 		 $ Body $ Var (size ftel2) []-          cltel  = (telFromList ptel) `abstract` ftel+          cltel  = ftel 	  clause = Clause { clauseRange = getRange info                           , clauseTel   = killRange cltel-                          , clausePerm  = idP $ size ptel + size ftel-                          , clausePats  = hps ++ [conp]+                          , clausePerm  = idP $ size ftel+                          , clausePats  = [conp]                           , clauseBody  = body                           }-          clause2 = Clauses Nothing clause-          cc      = compileClauses [clause2] +            -- Record patterns should /not/ be translated when the+            -- projection functions are defined. Record pattern+            -- translation is defined in terms of projection+            -- functions.+      cc <- compileClauses False [clause]+       reportSDoc "tc.cc" 10 $ do         sep [ text "compiled clauses of " <+> prettyTCM projname             , nest 2 $ text (show cc)             ]        escapeContext (size tel) $ do-	addConstant projname $ Defn rel projname (killRange finalt) (defaultDisplayForm projname) 0-          $ Function { funClauses        = [clause2]+	addConstant projname $ Defn rel projname (killRange finalt) (defaultDisplayForm projname) 0 noCompiledRep+          $ Function { funClauses        = [clause]                      , funCompiled       = cc                      , funDelayed        = NotDelayed                      , funInv            = NotInjective                      , funAbstr          = ConcreteDef                      , funPolarity       = []-                     , funArgOccurrences = map (const Unused) hps ++ [Negative]-                     , funProjection     = Just (size hps + 1)-                       -- index of the record argument, start counting with 1+                     , funArgOccurrences = [Negative]+                     , funProjection     = Just (r, size ptel + 1)+                       -- name of the record type and+                       -- index of the record argument (in the type), start counting with 1+                     , funStatic         = False                      }         computePolarity projname

src/full/Agda/TypeChecking/Rules/Term.hs view

@@ -12,12 +12,18 @@ import qualified Agda.Utils.IO.Locale as LocIO import qualified Data.Map as Map import qualified Data.Set as Set+import Data.Traversable (traverse) +import Agda.Interaction.Options+ import qualified Agda.Syntax.Abstract as A import qualified Agda.Syntax.Abstract.Views as A import qualified Agda.Syntax.Info as A import Agda.Syntax.Concrete.Pretty () -- only Pretty instances+import qualified Agda.Syntax.Concrete.Name as C import Agda.Syntax.Common+import Agda.Syntax.Translation.AbstractToConcrete+import Agda.Syntax.Concrete.Pretty import Agda.Syntax.Fixity import Agda.Syntax.Internal import Agda.Syntax.Internal.Generic@@ -25,6 +31,7 @@ import Agda.Syntax.Literal import Agda.Syntax.Abstract.Views import Agda.Syntax.Scope.Base (emptyScopeInfo)+import Agda.Syntax.Translation.InternalToAbstract (reify)  import Agda.TypeChecking.Monad import Agda.TypeChecking.Monad.Builtin@@ -39,18 +46,20 @@ import Agda.TypeChecking.Free import Agda.TypeChecking.Telescope import Agda.TypeChecking.Datatypes+import Agda.TypeChecking.Irrelevance import Agda.TypeChecking.EtaContract import Agda.TypeChecking.Quote import Agda.TypeChecking.CompiledClause+import Agda.TypeChecking.Level import {-# SOURCE #-} Agda.TypeChecking.Rules.Builtin.Coinduction  import Agda.Utils.Fresh import Agda.Utils.Tuple import Agda.Utils.Permutation -import {-# SOURCE #-} Agda.TypeChecking.Empty (isEmptyTypeC)+import {-# SOURCE #-} Agda.TypeChecking.Empty (isEmptyType) import {-# SOURCE #-} Agda.TypeChecking.Rules.Decl (checkSectionApplication)-import {-# SOURCE #-} Agda.TypeChecking.Rules.Def (checkFunDef)+import {-# SOURCE #-} Agda.TypeChecking.Rules.Def (checkFunDef,checkFunDef')  import Agda.Utils.Monad import Agda.Utils.Size@@ -72,19 +81,56 @@ -- | Check that an expression is a type without knowing the sort. isType_ :: A.Expr -> TCM Type isType_ e =-    traceCall (IsType_ e) $ do-    s <- newSortMeta-    isType e s+  traceCall (IsType_ e) $+  case e of+    A.Fun i a b -> do+      a <- traverse isType_ a+      b <- isType_ b+      return $ El (sLub (getSort $ unArg a) (getSort b)) (Pi a (NoAbs "_" b))+    A.Pi _ tel e -> do+      checkTelescope_ tel $ \tel -> do+        t   <- instantiateFull =<< isType_ e+        tel <- instantiateFull tel+        return $ telePi tel t+    A.Set _ n    -> do+      n <- ifM typeInType (return 0) (return n)+      return $ sort (mkType n)+    A.App i s (Arg NotHidden r l)+      | A.Set _ 0 <- unScope s ->+      ifM (not <$> hasUniversePolymorphism)+          (typeError $ GenericError "Use --universe-polymorphism to enable level arguments to Set")+      $ do+        lvl <- primLevel+        -- allow NonStrict variables when checking level+        --   Set : (NonStrict) Level -> Set\omega+        n   <- levelView =<< applyRelevanceToContext NonStrict+                              (checkExpr (namedThing l) (El (mkType 0) lvl))+        return $ sort (Type n)+    _ -> do+      s <- workOnTypes $ newSortMeta+      isType e s +-- | Check that an expression is a type which is equal to a given type.+isTypeEqualTo :: A.Expr -> Type -> TCM Type+isTypeEqualTo e t = case e of+  A.ScopedExpr _ e -> isTypeEqualTo e t+  A.Underscore i | A.metaNumber i == Nothing -> return t+  e -> do+    t' <- isType e (getSort t)+    t' <$ leqType_ t t'++leqType_ :: Type -> Type -> TCM ()+leqType_ t t' = workOnTypes $ leqType t t'++{- UNUSED -- | Force a type to be a Pi. Instantiates if necessary. The 'Hiding' is only --   used when instantiating a meta variable. -forcePi :: MonadTCM tcm => Hiding -> String -> Type -> tcm (Type, Constraints)+forcePi :: Hiding -> String -> Type -> TCM (Type, Constraints) forcePi h name (El s t) =     do	t' <- reduce t 	case t' of 	    Pi _ _	-> return (El s t', [])-	    Fun _ _	-> return (El s t', [])             _           -> do                 sa <- newSortMeta                 sb <- newSortMeta@@ -98,12 +144,13 @@                 cs <- equalType (El s t') ty                 ty' <- reduce ty                 return (ty', cs)-+-}  --------------------------------------------------------------------------- -- * Telescopes --------------------------------------------------------------------------- +{- UNUSED -- | Type check a telescope. Binds the variables defined by the telescope. checkTelescope :: A.Telescope -> Sort -> (Telescope -> TCM a) -> TCM a checkTelescope [] s ret = ret EmptyTel@@ -115,21 +162,21 @@ -- | Check a typed binding and extends the context with the bound variables. --   The telescope passed to the continuation is valid in the original context. checkTypedBindings :: A.TypedBindings -> Sort -> (Telescope -> TCM a) -> TCM a-checkTypedBindings (A.TypedBindings i (Arg h rel bs)) s ret =-    thread (checkTypedBinding h s) bs $ \bss ->-    ret $ foldr (\(x,t) -> ExtendTel (Arg h rel t) . Abs x) EmptyTel (concat bss)+checkTypedBindings (A.TypedBindings i (Arg h rel b)) s ret =+    checkTypedBinding h rel s b $ \bs ->+    ret $ foldr (\(x,t) -> ExtendTel (Arg h rel t) . Abs x) EmptyTel bs -checkTypedBinding :: Hiding -> Sort -> A.TypedBinding -> ([(String,Type)] -> TCM a) -> TCM a-checkTypedBinding h s (A.TBind i xs e) ret = do+checkTypedBinding :: Hiding -> Relevance -> Sort -> A.TypedBinding -> ([(String,Type)] -> TCM a) -> TCM a+checkTypedBinding h rel s (A.TBind i xs e) ret = do     t <- isType e s-    addCtxs xs (Arg h Relevant t) $ ret $ mkTel xs t+    addCtxs xs (Arg h rel t) $ ret $ mkTel xs t     where 	mkTel [] t     = [] 	mkTel (x:xs) t = (show $ nameConcrete x,t) : mkTel xs (raise 1 t)-checkTypedBinding h s (A.TNoBind e) ret = do+checkTypedBinding h rel s (A.TNoBind e) ret = do     t <- isType e s     ret [("_",t)]-+-}  -- | Type check a telescope. Binds the variables defined by the telescope. checkTelescope_ :: A.Telescope -> (Telescope -> TCM a) -> TCM a@@ -139,39 +186,110 @@     checkTelescope_ tel   $ \tel2 -> 	ret $ abstract tel1 tel2 - -- | Check a typed binding and extends the context with the bound variables. --   The telescope passed to the continuation is valid in the original context. checkTypedBindings_ :: A.TypedBindings -> (Telescope -> TCM a) -> TCM a-checkTypedBindings_ (A.TypedBindings i (Arg h rel bs)) ret =-    thread (checkTypedBinding_ h) bs $ \bss ->-    ret $ foldr (\(x,t) -> ExtendTel (Arg h rel t) . Abs x) EmptyTel (concat bss)+checkTypedBindings_ = checkTypedBindings PiNotLam -checkTypedBinding_ :: Hiding -> A.TypedBinding -> ([(String,Type)] -> TCM a) -> TCM a-checkTypedBinding_ h (A.TBind i xs e) ret = do-    t <- isType_ e-    addCtxs xs (Arg h Relevant t) $ ret $ mkTel xs t+data LamOrPi = LamNotPi | PiNotLam deriving (Eq,Show)++-- | Check a typed binding and extends the context with the bound variables.+--   The telescope passed to the continuation is valid in the original context.+--+--   Parametrized by a flag wether we check a typed lambda or a Pi. This flag+--   is needed for irrelevance.+checkTypedBindings :: LamOrPi -> A.TypedBindings -> (Telescope -> TCM a) -> TCM a+checkTypedBindings lamOrPi (A.TypedBindings i (Arg h rel b)) ret =+    checkTypedBinding lamOrPi h rel b $ \bs ->+    ret $ foldr (\(x,t) -> ExtendTel (Arg h rel t) . Abs x) EmptyTel bs++checkTypedBinding :: LamOrPi -> Hiding -> Relevance -> A.TypedBinding -> ([(String,Type)] -> TCM a) -> TCM a+checkTypedBinding lamOrPi h rel (A.TBind i xs e) ret = do+    -- Andreas, 2011-04-26 irrelevant function arguments may appear+    -- non-strictly in the codomain type+    -- 2011-10-04 if flag --experimental-irrelevance is set+    allowed <- optExperimentalIrrelevance <$> pragmaOptions+    t <- modEnv lamOrPi allowed $ isType_ e+    addCtxs xs (Arg h (modRel lamOrPi allowed rel) t) $ ret $ mkTel xs t     where+        -- if we are checking a typed lambda, we resurrect before we check the+        -- types, but do not modify the new context entries+        -- otherwise, if we are checking a pi, we do not resurrect, but+        -- modify the new context entries+        modEnv LamNotPi True = doWorkOnTypes+        modEnv _        _    = id+        modRel PiNotLam True = irrToNonStrict+        modRel _        _    = id 	mkTel [] t     = [] 	mkTel (x:xs) t = (show $ nameConcrete x,t) : mkTel xs (raise 1 t)-checkTypedBinding_ h (A.TNoBind e) ret = do+checkTypedBinding lamOrPi h rel (A.TNoBind e) ret = do     t <- isType_ e     ret [("_",t)] +-- | Type check a lambda expression.+checkLambda :: Arg A.TypedBinding -> A.Expr -> Type -> TCM Term+checkLambda (Arg _ _ A.TNoBind{}) _ _ = __IMPOSSIBLE__+checkLambda (Arg h r (A.TBind _ xs typ)) body target = do+  TelV tel btyp <- telViewUpTo (length xs) target+  if size tel < size xs || length xs /= 1+    then dontUseTargetType+    else useTargetType tel btyp+  where+    dontUseTargetType = do+      -- Checking λ (xs : argsT) → body : target+      verboseS "tc.term.lambda" 5 $ tick "lambda-no-target-type" +      -- First check that argsT is a valid type+      argsT <- workOnTypes $ Arg h r <$> isType_ typ++      -- In order to have as much type information as possible when checking+      -- body, we first unify (xs : argsT) → ?t₁ with the target type. If this+      -- is inconclusive we need to block the resulting term so we create a+      -- fresh problem for the check.+      t1 <- addCtxs xs argsT $ workOnTypes newTypeMeta_+      let tel = telFromList $ mkTel xs argsT+      pid <- newProblem_ $ leqType (telePi tel t1) target++      -- Now check body : ?t₁+      v <- addCtxs xs argsT $ checkExpr body t1++      -- Block on the type comparison+      blockTermOnProblem target (teleLam tel v) pid++    useTargetType tel@(ExtendTel arg (Abs _ EmptyTel)) btyp = do+        verboseS "tc.term.lambda" 5 $ tick "lambda-with-target-type"+        unless (argHiding    arg == h) $ typeError $ WrongHidingInLambda target+        -- Andreas, 2011-10-01 ignore relevance in lambda if not explicitly given+        let r' = argRelevance arg -- relevance of function type+        when (r == Irrelevant && r' /= r) $ typeError $ WrongIrrelevanceInLambda target+--        unless (argRelevance arg == r) $ typeError $ WrongIrrelevanceInLambda target+        -- We only need to block the final term on the argument type+        -- comparison. The body will be blocked if necessary. We still want to+        -- compare the argument types first, so we spawn a new problem for that+        -- check.+        (pid, argT) <- newProblem $ isTypeEqualTo typ (unArg arg)+        v <- addCtx x (Arg h r' argT) $ checkExpr body btyp+        blockTermOnProblem target (Lam h $ Abs (show $ nameConcrete x) v) pid+      where+        [x] = xs+    useTargetType _ _ = __IMPOSSIBLE__+++    mkTel []       t = []+    mkTel (x : xs) t = ((,) s <$> t) : mkTel xs (raise 1 t)+      where s = show $ nameConcrete x+ --------------------------------------------------------------------------- -- * Literal ---------------------------------------------------------------------------  checkLiteral :: Literal -> Type -> TCM Term checkLiteral lit t = do-    t' <- litType lit-    v  <- blockTerm t (Lit lit) $ leqType t' t-    return v+  t' <- litType lit+  blockTerm t $ Lit lit <$ leqType_ t' t  litType :: Literal -> TCM Type litType l = case l of-    LitLevel _ _  -> el <$> primLevel     LitInt _ _	  -> el <$> primNat     LitFloat _ _  -> el <$> primFloat     LitChar _ _   -> el <$> primChar@@ -185,7 +303,7 @@ ---------------------------------------------------------------------------  -- TODO: move somewhere suitable-reduceCon :: MonadTCM tcm => QName -> tcm QName+reduceCon :: QName -> TCM QName reduceCon c = do   Con c [] <- constructorForm =<< reduce (Con c [])   return c@@ -194,15 +312,24 @@ -- If it succeeds, it continues @k@ with the returned results.  If it fails, -- it registers a postponed typechecking problem and returns the resulting new -- meta variable.+--+-- Checks @e := ((_ : t0) args) : t@. checkArguments' ::   ExpandHidden -> Range -> [NamedArg A.Expr] -> Type -> Type -> A.Expr ->-  (Args -> Type -> Constraints -> TCM Term) -> TCM Term+  (Args -> Type -> TCM Term) -> TCM Term checkArguments' exph r args t0 t e k = do   z <- runErrorT $ checkArguments exph r args t0 t   case z of-    Right (vs, t1, cs) -> k vs t1 cs+    Right (vs, t1) -> k vs t1+      -- vs = evaluated args+      -- t1 = remaining type (needs to be subtype of t)+      -- cs = new constraints     Left t0            -> postponeTypeCheckingProblem e t (unblockedTester t0)+      -- if unsuccessful, postpone checking e : t until t0 unblocks +unScope (A.ScopedExpr scope e) = unScope e+unScope e                      = e+ -- | Type check an expression. checkExpr :: A.Expr -> Type -> TCM Term checkExpr e t =@@ -213,6 +340,8 @@ 	  [ fsep [ prettyTCM e, text ":", prettyTCM t ] 	  , nest 2 $ text "at " <+> (text . show =<< getCurrentRange) 	  ]+    reportSDoc "tc.term.expr.top.detailed" 80 $+      text "Checking" <+> fsep [ prettyTCM e, text ":", text (show t) ]     t <- reduce t     reportSDoc "tc.term.expr.top" 15 $         text "    --> " <+> prettyTCM t@@ -224,95 +353,52 @@      e <- scopedExpr e     case e of- 	-- Insert hidden lambda if appropriate-	_   | not (hiddenLambdaOrHole e)-	    , FunV (Arg Hidden _ _) _ <- funView (unEl t) -> do+	_   | Pi (Arg h rel _) _ <- unEl t+            , not (hiddenLambdaOrHole h e)+            , h /= NotHidden                          -> do 		x <- freshName r (argName t)                 reportSLn "tc.term.expr.impl" 15 $ "Inserting implicit lambda"-		checkExpr (A.Lam (A.ExprRange $ getRange e) (A.DomainFree Hidden x) e) t+		checkExpr (A.Lam (A.ExprRange $ getRange e) (domainFree h rel x) e) t 	    where 		r = case rStart $ getRange e of                       Nothing  -> noRange                       Just pos -> posToRange pos pos -                hiddenLambdaOrHole (A.AbsurdLam _ Hidden)                                  = True-		hiddenLambdaOrHole (A.Lam _ (A.DomainFree Hidden _) _)			   = True-		hiddenLambdaOrHole (A.Lam _ (A.DomainFull (A.TypedBindings _ (Arg Hidden _ _))) _) = True-		hiddenLambdaOrHole (A.QuestionMark _)					   = True-		hiddenLambdaOrHole _							   = False--	-- Variable or constant application-           -- Subcase: ambiguous constructor-	_   | Application (HeadCon cs@(_:_:_)) args <- appView e -> do-                -- First we should figure out which constructor we want.-                reportSLn "tc.check.term" 40 $ "Ambiguous constructor: " ++ show cs--                -- Get the datatypes of the various constructors-                let getData Constructor{conData = d} = d-                    getData _                        = __IMPOSSIBLE__-                reportSLn "tc.check.term" 40 $ "  ranges before: " ++ show (getRange cs)-                -- We use the reduced constructor when disambiguating, but-                -- the original constructor for type checking. This is important-                -- since they may have different types (different parameters).-                -- See issue 279.-                cs  <- zip cs . zipWith setRange (map getRange cs) <$> mapM reduceCon cs-                reportSLn "tc.check.term" 40 $ "  ranges after: " ++ show (getRange cs)-                reportSLn "tc.check.term" 40 $ "  reduced: " ++ show cs-                dcs <- mapM (\(c0, c1) -> (getData /\ const c0) . theDef <$> getConstInfo c1) cs--                -- Type error-                let badCon t = typeError $ DoesNotConstructAnElementOf-                                            (fst $ head cs) t+                hiddenLambdaOrHole h (A.AbsurdLam _ h') | h == h'                      = True+                hiddenLambdaOrHole h (A.ExtendedLam _ _ _ [])                          = False+                hiddenLambdaOrHole h (A.ExtendedLam _ _ _ cls)                         = any hiddenLHS cls+		hiddenLambdaOrHole h (A.Lam _ (A.DomainFree h' _ _) _) | h == h'       = True+		hiddenLambdaOrHole h (A.Lam _ (A.DomainFull (A.TypedBindings _ (Arg h' _ _))) _)+                  | h == h'                                                            = True+		hiddenLambdaOrHole _ (A.QuestionMark _)				       = True+		hiddenLambdaOrHole _ _						       = False -                -- Lets look at the target type at this point-                let getCon = do-                      TelV _ t1 <- telView t-                      t1 <- reduceB $ unEl t1-                      reportSDoc "tc.check.term.con" 40 $ nest 2 $-                        text "target type: " <+> prettyTCM t1-                      case t1 of-                        NotBlocked (Def d _) -> do-                          let dataOrRec = case [ c | (d', c) <- dcs, d == d' ] of-                                c:_ -> do-                                  reportSLn "tc.check.term" 40 $ "  decided on: " ++ show c-                                  return (Just c)-                                []  -> badCon (Def d [])-                          defn <- theDef <$> getConstInfo d-                          case defn of-                            Datatype{} -> dataOrRec-                            Record{}   -> dataOrRec-                            _ -> badCon (ignoreBlocking t1)-                        NotBlocked (MetaV _ _)  -> return Nothing-                        Blocked{} -> return Nothing-                        _ -> badCon (ignoreBlocking t1)-                let unblock = isJust <$> getCon-                mc <- getCon-                case mc of-                  Just c  -> checkConstructorApplication e t c args-                  Nothing -> postponeTypeCheckingProblem e t unblock+                hiddenLHS (A.Clause (A.LHS _ _ (a : _) _) _ _) = elem (argHiding a) [Hidden, Instance]+                hiddenLHS _ = False -              -- Subcase: non-ambiguous constructor-            | Application (HeadCon [c]) args <- appView e ->-                checkConstructorApplication e t c args-              -- Subcase: defined symbol or variable.-            | Application hd args <- appView e ->-                checkHeadApplication e t hd args+        -- a meta variable without arguments: type check directly for efficiency+	A.QuestionMark i -> checkMeta newQuestionMark t i+	A.Underscore i   -> checkMeta newValueMeta t i  	A.WithApp _ e es -> typeError $ NotImplemented "type checking of with application" +        -- check |- Set l : t  (requires universe polymorphism)         A.App i s (Arg NotHidden r l)           | A.Set _ 0 <- unScope s ->           ifM (not <$> hasUniversePolymorphism)               (typeError $ GenericError "Use --universe-polymorphism to enable level arguments to Set")           $ do             lvl <- primLevel-            suc <- do s <- primLevelSuc-                      return $ \x -> s `apply` [defaultArg x]-            n   <- checkExpr (namedThing l) (El (mkType 0) lvl)+            -- allow NonStrict variables when checking level+            --   Set : (NonStrict) Level -> Set\omega+            n   <- levelView =<< applyRelevanceToContext NonStrict+                                  (checkExpr (namedThing l) (El (mkType 0) lvl))+            -- check that Set (l+1) <= t             reportSDoc "tc.univ.poly" 10 $-              text "checking Set " <+> prettyTCM n <+> text "against" <+> prettyTCM t-            blockTerm t (Sort $ Type n) $ leqType (sort $ Type $ suc n) t+              text "checking Set " <+> prettyTCM n <+>+              text "against" <+> prettyTCM t+            blockTerm t $ Sort (Type n) <$ leqType_ (sort $ sSuc $ Type n) t          A.App i q (Arg NotHidden r e)           | A.Quote _ <- unScope q -> do@@ -323,48 +409,54 @@               quoted _                  = typeError $ GenericError $ "quote: not a defined name"           x <- quoted (namedThing e)           ty <- qNameType-          blockTerm t (quoteName x) $ leqType ty t+          blockTerm t $ quoteName x <$ leqType_ ty t -        A.Quote _ -> typeError $ GenericError "quote must be applied to a defined name"+          | A.QuoteTerm _ <- unScope q ->+             do (et, _) <- inferExpr (namedThing e)+                q <- quoteTerm =<< normalise et+                ty <- el primAgdaTerm+                blockTerm t $ q <$ leqType_ ty t -	A.App i e arg -> do-	    (v0, t0)	 <- inferExpr e-	    checkArguments' ExpandLast (getRange e) [arg] t0 t e $ \vs t1 cs ->-	      blockTerm t (apply v0 vs) $ (cs ++) <$> leqType t1 t+	  | A.Unquote _ <- unScope q ->+	     do e1 <- checkExpr (namedThing e) =<< el primAgdaTerm+	        e2 <- unquote e1+                checkTerm e2 t+        A.Quote _ -> typeError $ GenericError "quote must be applied to a defined name"+        A.QuoteTerm _ -> typeError $ GenericError "quoteTerm must be applied to a term"+        A.Unquote _ -> typeError $ GenericError "unquote must be applied to a term"          A.AbsurdLam i h -> do           t <- reduceB =<< instantiateFull t           case t of             Blocked{}                 -> postponeTypeCheckingProblem_ e $ ignoreBlocking t             NotBlocked (El _ MetaV{}) -> postponeTypeCheckingProblem_ e $ ignoreBlocking t-            NotBlocked t' -> case funView $ unEl t' of-              FunV (Arg h' _ a) _+            NotBlocked t' -> case unEl t' of+              Pi (Arg h' _ a) _                 | h == h' && not (null $ foldTerm metas a) ->                     postponeTypeCheckingProblem e (ignoreBlocking t) $                       null . foldTerm metas <$> instantiateFull a-                | h == h' -> do-                  cs' <- isEmptyTypeC a+                | h == h' -> blockTerm t' $ do+                  isEmptyType a                   -- Add helper function                   top <- currentModule                   let name = "absurd"                   aux <- qualify top <$> freshName (getRange i) name                   -- if we are in irrelevant position, the helper function                   -- is added as irrelevant-                  rel <- irrelevant <$> asks envIrrelevant+                  rel <- asks envRelevance                   reportSDoc "tc.term.absurd" 10 $ vcat                     [ text "Adding absurd function" <+> prettyTCM rel <> prettyTCM aux                     , nest 2 $ text "of type" <+> prettyTCM t'                     ]-                  addConstant aux $ Defn rel aux t' (defaultDisplayForm aux) 0+                  addConstant aux $ Defn rel aux t' (defaultDisplayForm aux) 0 noCompiledRep                                   $ Function                                     { funClauses        =-                                        [Clauses Nothing-                                                 (Clause { clauseRange = getRange e-                                                         , clauseTel   = EmptyTel-                                                         , clausePerm  = Perm 0 []-                                                         , clausePats  = [Arg h Relevant $ VarP "()"]-                                                         , clauseBody  = NoBody-                                                         })+                                        [Clause { clauseRange = getRange e+                                                , clauseTel   = EmptyTel+                                                , clausePerm  = Perm 0 []+                                                , clausePats  = [Arg h Relevant $ VarP "()"]+                                                , clauseBody  = NoBody+                                                }                                         ]                                     , funCompiled       = Fail                                     , funDelayed        = NotDelayed@@ -373,48 +465,76 @@                                     , funPolarity       = [Covariant]                                     , funArgOccurrences = [Unused]                                     , funProjection     = Nothing+                                    , funStatic         = False                                     }-                  blockTerm t' (Def aux []) $ return cs'+                  return (Def aux [])                 | otherwise -> typeError $ WrongHidingInLambda t'               _ -> typeError $ ShouldBePi t'           where             metas (MetaV m _) = [m]             metas _           = []+        A.ExtendedLam i di qname cs -> do+             t <- reduceB =<< instantiateFull t+             case t of+               Blocked{}                 -> postponeTypeCheckingProblem_ e $ ignoreBlocking t+               NotBlocked (El _ MetaV{}) -> postponeTypeCheckingProblem_ e $ ignoreBlocking t+               NotBlocked t -> do+                 j   <- currentMutualBlock+                 rel <- asks envRelevance+                 addConstant qname (Defn rel qname t (defaultDisplayForm qname) j noCompiledRep Axiom)+                 reportSDoc "tc.term.exlam" 50 $ text "extended lambda's implementation \"" <> prettyTCM qname <>+                                                 text "\" has type: " $$ prettyTCM t -- <+>+--                                                 text " where clauses: " <+> text (show cs)+                 abstract (A.defAbstract di) $ checkFunDef' t rel NotDelayed di qname cs+                 tel <- getContextTelescope+                 addExtLambdaTele qname (counthidden tel , countnothidden tel)+                 reduce $ (Def qname [] `apply` (mkArgs tel))+          where+	    -- Concrete definitions cannot use information about abstract things.+	    abstract ConcreteDef = inConcreteMode+	    abstract AbstractDef = inAbstractMode+            mkArgs :: Telescope -> Args+            mkArgs tel = map arg [n - 1, n - 2..0]+              where+                n     = size tel+                arg i = defaultArg (Var i []) +            metas (MetaV m _) = [m]+            metas _           = []++            counthidden :: Telescope -> Int+            counthidden t = length $ filter (\ (Arg h r a) -> h == Hidden ) $ teleArgs t++            countnothidden :: Telescope -> Int+            countnothidden t = length $ filter (\ (Arg h r a) -> h == NotHidden ) $ teleArgs t+++{- Andreas, 2011-04-27 DOES NOT WORK+   -- a telescope is not for type checking abstract syn+ 	A.Lam i (A.DomainFull b) e -> do-	    (v, cs) <- checkTypedBindings_ b $ \tel -> do-	        t1 <- newTypeMeta_-                cs <- escapeContext (size tel) $ leqType (telePi tel t1) t-                v <- checkExpr e t1-                return (teleLam tel v, cs)+            -- check the types, get the telescope with unchanged relevance+	    (tel, t1, cs) <- workOnTypes $ checkTypedBindings_ b $ \tel -> do+	       t1 <- newTypeMeta_+               cs <- escapeContext (size tel) $ leqType (telePi tel t1) t+               return (tel, t1, cs)+            -- check the body under the unchanged telescope+            v <- addCtxTel tel $ do teleLam tel <$> checkExpr e t1 	    blockTerm t v (return cs)+-}+	A.Lam i (A.DomainFull (A.TypedBindings _ b)) e -> checkLambda b e t -	A.Lam i (A.DomainFree h x) e0 -> do-	    -- (t',cs) <- forcePi h (show x) t-            t <- reduceB t-            case t of-              Blocked{}                 -> postponeTypeCheckingProblem_ e $ ignoreBlocking t-              NotBlocked (El _ MetaV{}) -> postponeTypeCheckingProblem_ e $ ignoreBlocking t-              NotBlocked t' -> case funView $ unEl t' of-		FunV arg0@(Arg h' r a) _-		    | h == h' -> do-			v <- addCtx x arg0 $ do-                              let arg = Arg h r (Var 0 [])-                                  tb  = raise 1 t' `piApply` [arg]-                              v <- checkExpr e0 tb-                              return $ Lam h $ Abs (show x) v-			-- blockTerm t v (return cs)-                        return v-		    | otherwise ->-			typeError $ WrongHidingInLambda t'-		_   -> typeError $ ShouldBePi t'+        -- 	A.Lam i (A.DomainFull b) e -> do+        -- 	    (v, cs) <- checkTypedBindings LamNotPi b $ \tel -> do+        --         (t1, cs) <- workOnTypes $ do+        -- 	          t1 <- newTypeMeta_+        --           cs <- escapeContext (size tel) $ leqType (telePi tel t1) t+        --           return (t1, cs)+        --         v <- checkExpr e t1+        --         return (teleLam tel v, cs)+        -- 	    blockTerm t v (return cs) -	A.QuestionMark i -> do-	    setScope (A.metaScope i)-	    newQuestionMark  t-	A.Underscore i   -> do-	    setScope (A.metaScope i)-	    newValueMeta t+	A.Lam i (A.DomainFree h rel x) e0 -> checkExpr (A.Lam i (domainFree h rel x) e0) t  	A.Lit lit    -> checkLiteral lit t 	A.Let i ds e -> checkLetBindings ds $ checkExpr e t@@ -422,26 +542,26 @@ 	    t' <- checkTelescope_ tel $ \tel -> do                     t   <- instantiateFull =<< isType_ e                     tel <- instantiateFull tel-                    return $ telePi_ tel t-            s  <- return $ getSort t'+                    return $ telePi tel t+            let s = getSort t'             when (s == Inf) $ reportSDoc "tc.term.sort" 20 $               vcat [ text ("reduced to omega:")                    , nest 2 $ text "t   =" <+> prettyTCM t'                    , nest 2 $ text "cxt =" <+> (prettyTCM =<< getContextTelescope)                    ]-	    blockTerm t (unEl t') $ leqType (sort s) t+	    blockTerm t $ unEl t' <$ leqType_ (sort s) t 	A.Fun _ (Arg h r a) b -> do 	    a' <- isType_ a 	    b' <- isType_ b-	    let s = getSort a' `sLub` getSort b'-	    blockTerm t (Fun (Arg h r a') b') $ leqType (sort s) t+	    s <- reduce $ getSort a' `sLub` getSort b'+	    blockTerm t $ Pi (Arg h r a') (NoAbs "_" b') <$ leqType_ (sort s) t 	A.Set _ n    -> do           n <- ifM typeInType (return 0) (return n)-	  blockTerm t (Sort (mkType n)) $ leqType (sort $ mkType $ n + 1) t+	  blockTerm t $ Sort (mkType n) <$ leqType_ (sort $ mkType $ n + 1) t 	A.Prop _     -> do           typeError $ GenericError "Prop is no longer supported"           -- s <- ifM typeInType (return $ mkType 0) (return Prop)-	  -- blockTerm t (Sort Prop) $ leqType (sort $ mkType 1) t+	  -- blockTerm t (Sort Prop) $ leqType_ (sort $ mkType 1) t  	A.Rec _ fs  -> do 	  t <- reduce t@@ -452,31 +572,88 @@ 	      ftel   <- getRecordFieldTypes r               con    <- getRecordConstructor r               scope  <- getScope+              let arg x e =+                    case [ a | a <- axs, unArg a == x ] of+                      [a] -> unnamed e <$ a+                      _   -> defaultArg $ unnamed e -- we only end up here if the field names are bad               let meta = A.Underscore $ A.MetaInfo (getRange e) scope Nothing-	      es   <- orderFields r meta xs fs+                  missingExplicits = [ (unArg a, [unnamed meta <$ a])+                                     | a <- axs, argHiding a == NotHidden+                                     , notElem (unArg a) (map fst fs) ]+              -- In es omitted explicit fields are replaced by underscores+              -- (from missingExplicits). Omitted implicit or instance fields+              -- are still left out and inserted later by checkArguments_.+	      es   <- concat <$> orderFields r [] xs ([ (x, [arg x e]) | (x, e) <- fs ] +++                                                      missingExplicits) 	      let tel = ftel `apply` vs-	      (args, cs) <- checkArguments_ ExpandLast (getRange e)-			      (zipWith (\ax e -> fmap (const (unnamed e)) ax) axs es)-                              tel-	      blockTerm t (Con con args) $ return cs+              args <- checkArguments_ ExpandLast (getRange e)+                        es -- (zipWith (\ax e -> fmap (const (unnamed e)) ax) axs es)+                        tel+              -- Don't need to block here!+	      return $ Con con args             MetaV _ _ -> do-              reportSDoc "tc.term.expr.rec" 10 $ sep-                [ text "Postponing type checking of"-                , nest 2 $ prettyA e <+> text ":" <+> prettyTCM t-                ]-              postponeTypeCheckingProblem_ e t+              let fields = map fst fs+              rs <- findPossibleRecords fields+              case rs of+                  -- If there are no records with the right fields we might as well fail right away.+                [] -> case fs of+                  []       -> typeError $ GenericError "There are no records in scope"+                  [(f, _)] -> typeError $ GenericError $ "There is no known record with the field " ++ show f+                  _        -> typeError $ GenericError $ "There is no known record with the fields " ++ unwords (map show fields)+                  -- If there's only one record with the appropriate fields, go with that.+                [r] -> do+                  def <- getConstInfo r+                  vs  <- newArgsMeta (defType def)+                  let target = piApply (defType def) vs+                      s      = case unEl target of+                                 Level l -> Type l+                                 Sort s  -> s+                                 _       -> __IMPOSSIBLE__+                      inferred = El s $ Def r vs+                  v <- checkExpr e inferred+                  blockTerm t $ v <$ leqType_ t inferred+                  -- If there are more than one possible record we postpone+                _:_:_ -> do+                  reportSDoc "tc.term.expr.rec" 10 $ sep+                    [ text "Postponing type checking of"+                    , nest 2 $ prettyA e <+> text ":" <+> prettyTCM t+                    ]+                  postponeTypeCheckingProblem_ e t 	    _         -> typeError $ ShouldBeRecordType t -	A.Var _    -> __IMPOSSIBLE__-	A.Def _    -> __IMPOSSIBLE__-	A.Con _    -> __IMPOSSIBLE__--        A.ETel _   -> __IMPOSSIBLE__--	A.DontCare -> -- can happen in the context of with functions-                      return DontCare-                      -- __IMPOSSIBLE__+        A.RecUpdate ei recexpr fs -> do+          case unEl t of+            Def r vs  -> do+              rec <- checkExpr recexpr t+              name <- freshNoName (getRange recexpr)+              addLetBinding Relevant name rec t $ do+                projs <- recFields <$> getRecordDef r+                axs <- getRecordFieldNames r+                scope <- getScope+                let xs = map unArg axs+                es <- orderFields r Nothing xs $ map (\(x, e) -> (x, Just e)) fs+                let es' = zipWith (replaceFields name ei) projs es+                checkExpr (A.Rec ei [ (x, e) | (x, Just e) <- zip xs es' ]) t+            MetaV _ _ -> do+              inferred <- inferExpr recexpr >>= reduce . snd+              case unEl inferred of+                MetaV _ _ -> postponeTypeCheckingProblem_ e t+                _         -> do+                  v <- checkExpr e inferred+                  blockTerm t $ v <$ leqType_ t inferred+            _         -> typeError $ ShouldBeRecordType t+          where+            replaceFields :: Name -> A.ExprInfo -> Arg A.QName -> Maybe A.Expr -> Maybe A.Expr+            replaceFields n ei (Arg NotHidden _ p) Nothing  = Just $ A.App ei (A.Def p) $ defaultArg (unnamed $ A.Var n)+            replaceFields _ _  (Arg _         _ _) Nothing  = Nothing+            replaceFields _ _  _                   (Just e) = Just $ e +	A.DontCare e -> -- can happen in the context of with functions+          checkExpr e t+{- Andreas, 2011-10-03 why do I get an internal error for Issue337?+                        -- except that should be fixed now (issue 337)+                        __IMPOSSIBLE__+-} 	A.ScopedExpr scope e -> setScope scope >> checkExpr e t          e0@(A.QuoteGoal _ x e) -> do@@ -488,22 +665,134 @@           case metas of             _:_ -> postponeTypeCheckingProblem e0 t' $ and <$> mapM isInstantiatedMeta metas             []  -> do-              quoted <- quoteType t'+              quoted <- quoteTerm (unEl t')               tmType <- agdaTermType-              (v,ty) <- addLetBinding Relevant x quoted tmType (inferExpr e)-              blockTerm t' v $ leqType ty t'+              (v, ty) <- addLetBinding Relevant x quoted tmType (inferExpr e)+              blockTerm t' $ v <$ leqType_ ty t' +        A.ETel _   -> __IMPOSSIBLE__++	-- Application+          -- Subcase: ambiguous constructor+	_   | Application (A.Con (AmbQ cs@(_:_:_))) args <- appView e -> do+                -- First we should figure out which constructor we want.+                reportSLn "tc.check.term" 40 $ "Ambiguous constructor: " ++ show cs++                -- Get the datatypes of the various constructors+                let getData Constructor{conData = d} = d+                    getData _                        = __IMPOSSIBLE__+                reportSLn "tc.check.term" 40 $ "  ranges before: " ++ show (getRange cs)+                -- We use the reduced constructor when disambiguating, but+                -- the original constructor for type checking. This is important+                -- since they may have different types (different parameters).+                -- See issue 279.+                cs  <- zip cs . zipWith setRange (map getRange cs) <$> mapM reduceCon cs+                reportSLn "tc.check.term" 40 $ "  ranges after: " ++ show (getRange cs)+                reportSLn "tc.check.term" 40 $ "  reduced: " ++ show cs+                dcs <- mapM (\(c0, c1) -> (getData /\ const c0) . theDef <$> getConstInfo c1) cs++                -- Type error+                let badCon t = typeError $ DoesNotConstructAnElementOf+                                            (fst $ head cs) t++                -- Lets look at the target type at this point+                let getCon = do+                      TelV _ t1 <- telView t+                      t1 <- reduceB $ unEl t1+                      reportSDoc "tc.check.term.con" 40 $ nest 2 $+                        text "target type: " <+> prettyTCM t1+                      case t1 of+                        NotBlocked (Def d _) -> do+                          let dataOrRec = case [ c | (d', c) <- dcs, d == d' ] of+                                [c] -> do+                                  reportSLn "tc.check.term" 40 $ "  decided on: " ++ show c+                                  return (Just c)+                                []  -> badCon (Def d [])+                                cs  -> typeError $ GenericError $+                                        "Can't resolve overloaded constructors targeting the same datatype (" ++ show d +++                                        "): " ++ unwords (map show cs)+                          defn <- theDef <$> getConstInfo d+                          case defn of+                            Datatype{} -> dataOrRec+                            Record{}   -> dataOrRec+                            _ -> badCon (ignoreBlocking t1)+                        NotBlocked (MetaV _ _)  -> return Nothing+                        Blocked{} -> return Nothing+                        _ -> badCon (ignoreBlocking t1)+                let unblock = isJust <$> getCon+                mc <- getCon+                case mc of+                  Just c  -> checkConstructorApplication e t c args+                  Nothing -> postponeTypeCheckingProblem e t unblock++              -- Subcase: non-ambiguous constructor+            | Application (A.Con (AmbQ [c])) args <- appView e ->+                checkConstructorApplication e t c args+              -- Subcase: defined symbol or variable.+            | Application hd args <- appView e ->+                checkHeadApplication e t hd args++domainFree h rel x =+  A.DomainFull $ A.TypedBindings r $ Arg h rel $ A.TBind r [x] $ A.Underscore info+  where+    r = getRange x+    info = A.MetaInfo{ A.metaRange = r, A.metaScope = emptyScopeInfo, A.metaNumber = Nothing }++checkMeta :: (Type -> TCM Term) -> Type -> A.MetaInfo -> TCM Term+checkMeta newMeta t i = do+  case A.metaNumber i of+    Nothing -> do+      setScope (A.metaScope i)+      newMeta t+    -- Rechecking an existing metavariable+    Just n -> do+      let v = MetaV (MetaId n) []+      t' <- jMetaType . mvJudgement <$> lookupMeta (MetaId n)+      blockTerm t $ v <$ leqType t' t++inferMeta :: (Type -> TCM Term) -> A.MetaInfo -> TCM (Args -> Term, Type)+inferMeta newMeta i =+  case A.metaNumber i of+    Nothing -> do+      setScope (A.metaScope i)+      t <- workOnTypes $ newTypeMeta_+      v <- newMeta t+      return (apply v, t)+    -- Rechecking an existing metavariable+    Just n -> do+      let v = MetaV (MetaId n)+      t' <- jMetaType . mvJudgement <$> lookupMeta (MetaId n)+      return (v, t')+ -- | Infer the type of a head thing (variable, function symbol, or constructor)-inferHead :: Head -> TCM (Args -> Term, Type)-inferHead (HeadVar x) = do -- traceCall (InferVar x) $ do+inferHead :: A.Expr -> TCM (Args -> Term, Type)+inferHead (A.Var x) = do -- traceCall (InferVar x) $ do   (u, a) <- getVarInfo x-  when (argRelevance a == Irrelevant) $+  when (unusableRelevance $ argRelevance a) $     typeError $ VariableIsIrrelevant x   return (apply u, unArg a)-inferHead (HeadDef x) = do-  (u, a) <- inferDef Def x-  return (apply u, a)-inferHead (HeadCon [c]) = do+inferHead (A.Def x) = do+  proj <- isProjection x+  case proj of+    Nothing -> do+      (u, a) <- inferDef Def x+      return (apply u, a)+    Just{} -> do+      Just (r, n) <- funProjection . theDef <$> getConstInfo x+      cxt <- size <$> freeVarsToApply x+      m <- getDefFreeVars x+      reportSDoc "tc.term.proj" 10 $ sep+        [ text "building projection" <+> prettyTCM x+        , nest 2 $ parens (text "ctx =" <+> text (show cxt))+        , nest 2 $ parens (text "n =" <+> text (show n))+        , nest 2 $ parens (text "m =" <+> text (show m)) ]+      let hs | n == 0    = __IMPOSSIBLE__+             | otherwise = genericReplicate (n - 1) NotHidden -- TODO: hiding+          names = [ s ++ [c] | s <- "" : names, c <- ['a'..'z'] ]+          eta   = foldr (\(h, s) -> Lam h . NoAbs s) (Def x []) (zip hs names)+      (u, a) <- inferDef (\f vs -> eta `apply` vs) x+      return (apply u, a)+inferHead (A.Con (AmbQ [c])) = do    -- Constructors are polymorphic internally so when building the constructor   -- term we should throw away arguments corresponding to parameters.@@ -520,16 +809,25 @@    -- So when applying the constructor throw away the parameters.   return (apply u . genericDrop n, a)-inferHead (HeadCon _) = __IMPOSSIBLE__  -- inferHead will only be called on unambiguous constructors+inferHead (A.Con _) = __IMPOSSIBLE__  -- inferHead will only be called on unambiguous constructors+inferHead (A.QuestionMark i)  = inferMeta newQuestionMark i+inferHead (A.Underscore i) = inferMeta newValueMeta i+inferHead e = do (term, t) <- inferExpr e+                 return (apply term, t)  inferDef :: (QName -> Args -> Term) -> QName -> TCM (Term, Type) inferDef mkTerm x =     traceCall (InferDef (getRange x) x) $ do     d  <- instantiateDef =<< getConstInfo x     -- irrelevant defs are only allowed in irrelevant position-    when (defRelevance d == Irrelevant) $ do-      irr <- asks envIrrelevant-      unless irr $ typeError $ DefinitionIsIrrelevant x+    let drel = defRelevance d+    when (drel /= Relevant) $ do+      rel <- asks envRelevance+      reportSDoc "tc.irr" 50 $ vcat+        [ text "declaration relevance =" <+> text (show drel)+        , text "context     relevance =" <+> text (show rel)+        ]+      unless (drel `moreRelevant` rel) $ typeError $ DefinitionIsIrrelevant x     vs <- freeVarsToApply x     verboseS "tc.term.def" 10 $ do       ds <- mapM prettyTCM vs@@ -542,84 +840,43 @@ --   a general application since the implicit arguments can be inserted --   without looking at the arguments to the constructor. checkConstructorApplication :: A.Expr -> Type -> QName -> [NamedArg A.Expr] -> TCM Term-checkConstructorApplication org t c args = do-  checkHead t args-{--  TelV gamma d <- telView t--  -- Eta expand the constructor applications so it's fully applied-  let realName "_" = "carg"-      realName  x  = x-      gamma' = telToList gamma--    -- Generate fresh names for eta expansion variables-  vars <- sequence [ Arg h <$> freshName_ (realName x)-                   | Arg h (x, _) <- gamma' ]--    -- Compute the context of the variables-  let cxt = [ (unArg x, fmap snd t) | (x, t) <- zip vars gamma' ]-      extendCxt cxt m = foldr (uncurry addCtx) m cxt-      etaExpansion t = foldr lam t gamma'-        where lam (Arg h (x, _)) t = Lam h (Abs x t)--  -- Go inside the lambdas generated by the expansion-  extendCxt cxt $ do--  -- Make sure to shadow some things we shouldn't use-  t        <- return d-  args     <- return $ args ++ map (fmap (unnamed . A.Var)) vars-  fallback <- return $ etaExpansion <$> checkHead t args--  -- Make sure we're checking against the right datatype-  d   <- getConstructorData c-  mdi <- getDatatypeInfo t-  case mdi of-    Nothing -> fallback-    Just dinfo@DataInfo{ datatypeName   = d'-                       , datatypeParTel = parTel-                       , datatypePars   = dpars-                       , datatypeIxTel  = ixTel-                       , datatypeIxs    = indices-                       }-      | d /= d'   -> fallback-      | otherwise -> do--      -- Split the given arguments into explicitly given parameters and normal-      -- arguments-      (pars, args) <- return $ splitArgs (map (fst . unArg) $ telToList parTel)-                                         args--      reportSDoc "tc.term.con" 30 $ vcat-        [ text "checking constructor application"-        , nest 2 $ vcat-          [ text "c      =" <+> prettyTCM c-          , text "A.pars =" <+> prettyList (map prettyA pars)-          , text "A.args =" <+> prettyList (map prettyA args)-          , text "ptel   =" <+> prettyTCM parTel-          , text "itel   =" <+> addCtxTel parTel (prettyTCM ixTel)-          , text "pars   =" <+> prettyTCM dpars-          , text "ixs    =" <+> prettyTCM indices-          ]-        ]--      -- Check the parameters. Just means checking that any given-      -- parameters are equal to the expected parameters.-      -- checkParams pars parTel $ do--      fallback--  -- Plan-  --  * Check the parameters-  --    + if they're present type check and compare to the parameters to the-  --      datatype, otherwise just continue-  --  * Insert implicit constructor arguments (not counting parameters)-  --  * Check the arguments-  --  * Compare the computed indices from the constructor with the given-  --    indices--}+checkConstructorApplication org t c args+  | hiddenArg = fallback+  | otherwise = do+    cdef  <- getConstInfo c+    let Constructor{conData = d} = theDef cdef+    case unEl t of -- Only fully applied constructors get special treatment+      Def d' vs | d' == d -> do+        def <- theDef <$> getConstInfo d+        let npars = case def of+                      Datatype{ dataPars = n } -> Just n+                      Record{ recPars = n }    -> Just n+                      _                        -> Nothing+        flip (maybe fallback) npars $ \n -> do+        let ps    = genericTake n vs+            ctype = defType cdef+        reportSDoc "tc.term.con" 20 $ vcat+          [ text "special checking of constructor application of" <+> prettyTCM c+          , nest 2 $ vcat [ text "ps     =" <+> prettyTCM ps+                          , text "ctype  =" <+> prettyTCM ctype ] ]+        let ctype' = ctype `piApply` ps+        reportSDoc "tc.term.con" 20 $ nest 2 $ text "ctype' =" <+> prettyTCM ctype'+        checkArguments' ExpandLast (getRange c) args ctype' t org $ \us t' -> do+          reportSDoc "tc.term.con" 20 $ nest 2 $ vcat+            [ text "us     =" <+> prettyTCM us+            , text "t'     =" <+> prettyTCM t' ]+          blockTerm t $ Con c us <$ leqType_ t' t+      _ -> fallback   where-    checkHead t args = checkHeadApplication org t (HeadCon [c]) args+    fallback = checkHeadApplication org t (A.Con (AmbQ [c])) args +    -- Check if there are explicitly given hidden arguments,+    -- in which case we fall back to default type checking.+    -- We could work harder, but let's not for now.+    hiddenArg = case args of+      Arg Hidden _ _ : _ -> True+      _                  -> False+     -- Split the arguments to a constructor into those corresponding     -- to parameters and those that don't. Dummy underscores are inserted     -- for parameters that are not given explicitly.@@ -638,38 +895,6 @@      dummyUnderscore = Arg Hidden Relevant (unnamed $ A.Underscore $ A.MetaInfo noRange emptyScopeInfo Nothing) ---   TelV _ (El _ (Def d dargs)) <- telView t---   condef  <- getConstInfo c---   let pars = map unArg $ genericTake (conPars $ theDef condef) dargs---   (_, contype) <- inferHead (HeadCon [c])---   TelV contel _ <- telView contype---   let args' = insertParams contel pars args---   reportSDoc "tc.term.con" 10 $ vcat---     [ text "Checking constructor application"---     , nest 2 $ vcat---       [ text "args  =" <+> prettyList (map prettyA args)---       , text "args' =" <+> prettyList (map prettyA args')---       ]---     ]---   checkHeadApplication org t (HeadCon [c]) args'---   where---     insertParams :: Telescope -> [Term] -> [NamedArg A.Expr] -> [NamedArg A.Expr]---     insertParams _ [] args = args---     insertParams (ExtendTel a tel) (p:ps) (arg:args)---       | argHiding arg == NotHidden ||---         notElem argname [Nothing, telname] =---           Arg Hidden (unnamed $ A.TypeChecked p) :---           insertParams (absBody tel) ps (arg:args)---       | otherwise =---           arg : insertParams (absBody tel) ps args---       where---         argname = nameOf (unArg arg)---         telname = Just (absName tel)---     insertParams (ExtendTel a tel) (p:ps) [] =---           Arg Hidden (unnamed $ A.TypeChecked p) :---           insertParams (absBody tel) ps []---     insertParams EmptyTel (_:_) _ = __IMPOSSIBLE__- -- | @checkHeadApplication e t hd args@ checks that @e@ has type @t@, -- assuming that @e@ has the form @hd args@. The corresponding -- type-checked term is returned.@@ -681,42 +906,43 @@ -- -- Precondition: The head @hd@ has to be unambiguous, and there should -- not be any need to insert hidden lambdas.-checkHeadApplication :: A.Expr -> Type -> A.Head -> [NamedArg A.Expr] -> TCM Term+checkHeadApplication :: A.Expr -> Type -> A.Expr -> [NamedArg A.Expr] -> TCM Term checkHeadApplication e t hd args = do-  replacing <- envReplace <$> ask   kit       <- coinductionKit-  if not replacing-   then local (\e -> e { envReplace = True }) defaultResult-   else case hd of-    HeadCon [c] -> do+  case hd of+    A.Con (AmbQ [c]) | Just c == (nameOfSharp <$> kit) -> do+      -- Type checking # generated #-wrapper. The # that the user can write will be a Def,+      -- but the sharp we generate in the body of the wrapper is a Con.+      defaultResult+    A.Con (AmbQ [c]) -> do       (f, t0) <- inferHead hd       reportSDoc "tc.term.con" 5 $ vcat         [ text "checkHeadApplication inferred" <+>           prettyTCM c <+> text ":" <+> prettyTCM t0         ]-      checkArguments' ExpandLast (getRange hd) args t0 t e $ \vs t1 cs -> do+      checkArguments' ExpandLast (getRange hd) args t0 t e $ \vs t1 -> do         TelV eTel eType <- telView t         -- If the expected type @eType@ is a metavariable we have to make         -- sure it's instantiated to the proper pi type         TelV fTel fType <- telViewUpTo (size eTel) t1-        blockTerm t (f vs) $ (cs ++) <$> do-          -- We know that the target type of the constructor (fType)-          -- does not depend on fTel so we can compare fType and eType-          -- first.--          when (size eTel > size fTel) $-            compareTel CmpLeq eTel fTel >> return () -- This will fail!+        -- We know that the target type of the constructor (fType)+        -- does not depend on fTel so we can compare fType and eType+        -- first. -          reportSDoc "tc.term.con" 10 $ vcat-            [ text "checking" <+>-              prettyTCM fType <+> text "?<=" <+> prettyTCM eType-            ]-          cs1 <- addCtxTel eTel $ leqType fType eType+        when (size eTel > size fTel) $+          typeError $ UnequalTypes CmpLeq t1 t -- switch because of contravariance+          -- Andreas, 2011-05-10 report error about types rather  telescopes+          -- compareTel CmpLeq eTel fTel >> return () -- This will fail! -          cs2 <- compareTel CmpLeq eTel fTel-          return $ cs1 ++ cs2+        reportSDoc "tc.term.con" 10 $ vcat+          [ text "checking" <+>+            prettyTCM fType <+> text "?<=" <+> prettyTCM eType+          ]+        blockTerm t $ f vs <$ workOnTypes (do+          addCtxTel eTel $ leqType fType eType+          compareTel t t1 CmpLeq eTel fTel) -    HeadDef c | Just c == (nameOfSharp <$> kit) -> do+    (A.Def c) | Just c == (nameOfSharp <$> kit) -> do       -- TODO: Handle coinductive constructors under lets.       lets <- envLetBindings <$> ask       unless (Map.null lets) $@@ -726,7 +952,7 @@       -- The name of the fresh function.       i <- fresh :: TCM Integer       let name = filter (/= '_') (show $ A.qnameName c) ++ "-" ++ show i-      c' <- liftM2 qualify currentModule (freshName_ name)+      c' <- liftM2 qualify (killRange <$> currentModule) (freshName_ name)        -- The application of the fresh function to the relevant       -- arguments.@@ -738,8 +964,8 @@       tel <- getContextTelescope       -- If we are in irrelevant position, add definition irrelevantly.       -- TODO: is this sufficient?-      rel <- irrelevant <$> asks envIrrelevant-      addConstant c' (Defn rel c' t (defaultDisplayForm c') i $ Axiom Nothing Nothing)+      rel <- asks envRelevance+      addConstant c' (Defn rel c' t (defaultDisplayForm c') i noCompiledRep $ Axiom)        -- Define and type check the fresh function.       ctx <- getContext@@ -748,7 +974,7 @@           pats   = map (fmap $ \(n, _) -> Named Nothing (A.VarP n)) $                        reverse ctx           clause = A.Clause (A.LHS (A.LHSRange noRange) c' pats [])-                            (A.RHS $ unAppView (A.Application hd args))+                            (A.RHS $ unAppView (A.Application (A.Con (AmbQ [c])) args))                             []        reportSDoc "tc.term.expr.coind" 15 $ vcat $@@ -762,8 +988,7 @@           , nest 2 $ prettyA clause <> text "."           ] -      local (\e -> e { envReplace = False }) $-        escapeContext (size ctx) $ checkFunDef Delayed info c' [clause]+      escapeContext (size ctx) $ checkFunDef Delayed info c' [clause]        reportSDoc "tc.term.expr.coind" 15 $ do         def <- theDef <$> getConstInfo c'@@ -771,14 +996,13 @@           text "."        return e'-    HeadCon _  -> __IMPOSSIBLE__-    HeadVar {} -> defaultResult-    HeadDef {} -> defaultResult+    A.Con _  -> __IMPOSSIBLE__+    _ -> defaultResult   where   defaultResult = do     (f, t0) <- inferHead hd-    checkArguments' ExpandLast (getRange hd) args t0 t e $ \vs t1 cs ->-      blockTerm t (f vs) $ (cs ++) <$> leqType t1 t+    checkArguments' ExpandLast (getRange hd) args t0 t e $ \vs t1 ->+      blockTerm t $ f vs <$ leqType_ t1 t  data ExpandHidden = ExpandLast | DontExpandLast @@ -799,27 +1023,34 @@  -- | Check a list of arguments: @checkArgs args t0 t1@ checks that --   @t0 = Delta -> t0'@ and @args : Delta@. Inserts hidden arguments to---   make this happen. Returns @t0'@ and any constraints that have to be---   solve for everything to be well-formed.+--   make this happen.  Returns the evaluated arguments @vs@, the remaining+--   type @t0'@ (which should be a subtype of @t1@) and any constraints @cs@+--   that have to be solved for everything to be well-formed.+-- --   TODO: doesn't do proper blocking of terms checkArguments :: ExpandHidden -> Range -> [NamedArg A.Expr] -> Type -> Type ->-                  ErrorT Type TCM (Args, Type, Constraints)-checkArguments DontExpandLast _ [] t0 t1 = return ([], t0, [])+                  ErrorT Type TCM (Args, Type)+checkArguments DontExpandLast _ [] t0 t1 = return ([], t0) checkArguments exh r [] t0 t1 =     traceCallE (CheckArguments r [] t0 t1) $ do 	t0' <- lift $ reduce t0 	t1' <- lift $ reduce t1-	case funView $ unEl t0' of -- TODO: clean-	    FunV (Arg Hidden rel a) _ | notHPi $ unEl t1'  -> do+	case unEl t0' of+	    Pi (Arg Hidden rel a) _ | notHPi Hidden $ unEl t1'  -> do 		v  <- lift $ applyRelevanceToContext rel $ newValueMeta a 		let arg = Arg Hidden rel v-		(vs, t0'',cs) <- checkArguments exh r [] (piApply t0' [arg]) t1'-		return (arg : vs, t0'',cs)-	    _ -> return ([], t0', [])+		(vs, t0'') <- checkArguments exh r [] (piApply t0' [arg]) t1'+		return (arg : vs, t0'')+	    Pi (Arg Instance rel a) _ | notHPi Instance $ unEl t1'  -> do+                lift $ reportSLn "tc.term.args.ifs" 15 $ "inserting implicit meta for type " ++ show a+		v <- lift $ applyRelevanceToContext rel $ newIFSMeta a+		let arg = Arg Instance rel v+		(vs, t0'') <- checkArguments exh r [] (piApply t0' [arg]) t1'+		return (arg : vs, t0'')+	    _ -> return ([], t0')     where-	notHPi (Pi  (Arg Hidden _ _) _) = False-	notHPi (Fun (Arg Hidden _ _) _) = False-	notHPi _		        = True+	notHPi h (Pi  (Arg h' _ _) _) | h == h' = False+	notHPi _ _		        = True  checkArguments exh r args0@(Arg h _ e : args) t0 t1 =     traceCallE (CheckArguments r args0 t0 t1) $ do@@ -830,23 +1061,28 @@         NotBlocked t0' -> do           -- (t0', cs) <- forcePi h (name e) t0           e' <- return $ namedThing e-          case (h, funView $ unEl t0') of-              (NotHidden, FunV (Arg Hidden rel a) _) -> insertUnderscore rel-              (Hidden, FunV (Arg Hidden rel a) _)-                  | not $ sameName (nameOf e) (nameInPi $ unEl t0') -> insertUnderscore rel-              (_, FunV (Arg h' rel a) _) | h == h' -> do+          case unEl t0' of+              Pi (Arg h' rel a) _ |+                h == h' && (h == NotHidden || sameName (nameOf e) (nameInPi $ unEl t0')) -> do                   u  <- lift $ applyRelevanceToContext rel $ checkExpr e' a                   let arg = Arg h rel u  -- save relevance info in argument-                  (us, t0'', cs') <- checkArguments exh (fuseRange r e) args (piApply t0' [arg]) t1-                  return (nukeIfIrrelevant arg : us, t0'', cs')+                  (us, t0'') <- checkArguments exh (fuseRange r e) args (piApply t0' [arg]) t1+                  return (nukeIfIrrelevant arg : us, t0'')                          where nukeIfIrrelevant arg =                                  if argRelevance arg == Irrelevant then-                                   arg { unArg = DontCare }+   -- Andreas, 2011-09-09 keep irr. args. until after termination checking+                                   arg { unArg = DontCare $ unArg arg }                                   else arg-              (Hidden, FunV (Arg NotHidden _ _) _) ->-                  lift $ typeError $ WrongHidingInApplication t0'+              Pi (Arg Instance rel a) _ -> insertIFSUnderscore rel a+              Pi (Arg Hidden rel a) _   -> insertUnderscore rel+              Pi (Arg NotHidden _ _) _  -> lift $ typeError $ WrongHidingInApplication t0'               _ -> lift $ typeError $ ShouldBePi t0'     where+	insertIFSUnderscore rel a = do v <- lift $ applyRelevanceToContext rel $ newIFSMeta a+                                       lift $ reportSLn "tc.term.args.ifs" 15 $ "inserting implicit meta (2) for type " ++ show a+                                       let arg = Arg Instance rel v+                                       (vs, t0'') <- checkArguments exh r args0 (piApply t0 [arg]) t1+                                       return (arg : vs, t0'') 	insertUnderscore rel = do 	  scope <- lift $ getScope 	  let m = A.Underscore $ A.MetaInfo@@ -864,27 +1100,31 @@ 	sameName n1	 n2 = n1 == n2  	nameInPi (Pi _ b)  = Just $ absName b-	nameInPi (Fun _ _) = Nothing 	nameInPi _	   = __IMPOSSIBLE__   -- | Check that a list of arguments fits a telescope.-checkArguments_ :: ExpandHidden -> Range -> [NamedArg A.Expr] -> Telescope -> TCM (Args, Constraints)+checkArguments_ :: ExpandHidden -> Range -> [NamedArg A.Expr] -> Telescope -> TCM Args checkArguments_ exh r args tel = do     z <- runErrorT $ checkArguments exh r args (telePi tel $ sort Prop) (sort Prop)     case z of-      Right (args, _, cs) -> return (args, cs)-      Left _              -> __IMPOSSIBLE__+      Right (args, _) -> return args+      Left _          -> __IMPOSSIBLE__  --- | Infer the type of an expression. Implemented by checking agains a meta+-- | Infer the type of an expression. Implemented by checking against a meta --   variable. inferExpr :: A.Expr -> TCM (Term, Type) inferExpr e = do-    t <- newTypeMeta_+    -- Andreas, 2011-04-27+    t <- workOnTypes $ newTypeMeta_     v <- checkExpr e t     return (v,t) +checkTerm :: Term -> Type -> TCM Term+checkTerm tm ty = do atm <- reify tm+                     checkExpr atm ty+ --------------------------------------------------------------------------- -- * Let bindings ---------------------------------------------------------------------------@@ -898,20 +1138,20 @@     t <- isType_ t     v <- applyRelevanceToContext rel $ checkExpr e t     addLetBinding rel x v t ret-checkLetBinding (A.LetApply i x tel m args rd rm) ret = do+checkLetBinding (A.LetApply i x modapp rd rm) ret = do   -- Any variables in the context that doesn't belong to the current   -- module should go with the new module.   -- fv   <- getDefFreeVars =<< (qnameFromList . mnameToList) <$> currentModule   fv   <- getModuleFreeVars =<< currentModule   n    <- size <$> getContext   let new = n - fv-  reportSLn "tc.term.let.apply" 10 $ "Applying " ++ show m ++ " with " ++ show new ++ " free variables"+  reportSLn "tc.term.let.apply" 10 $ "Applying " ++ show modapp ++ " with " ++ show new ++ " free variables"   reportSDoc "tc.term.let.apply" 20 $ vcat     [ text "context =" <+> (prettyTCM =<< getContextTelescope)     , text "module  =" <+> (prettyTCM =<< currentModule)     , text "fv      =" <+> (text $ show fv)     ]-  checkSectionApplication i x tel m args rd rm+  checkSectionApplication i x modapp rd rm   withAnonymousModule x new ret -- LetOpen is only used for highlighting and has no semantics checkLetBinding A.LetOpen{} ret = ret

src/full/Agda/TypeChecking/Rules/Term.hs-boot view

@@ -6,4 +6,3 @@ import Agda.TypeChecking.Monad.Base  checkExpr :: A.Expr -> Type -> TCM Term-

src/full/Agda/TypeChecking/Serialise.hs view

@@ -1,5 +1,6 @@ {-# LANGUAGE OverlappingInstances,              TypeSynonymInstances,+             FlexibleInstances,              IncoherentInstances,              ExistentialQuantification,              ScopedTypeVariables,@@ -23,6 +24,7 @@   )   where +import Control.Applicative import qualified Control.Exception as E import Control.Monad import Control.Monad.Reader@@ -32,8 +34,8 @@ import Data.Bits (shiftR) import Data.Word import Data.ByteString.Lazy as L-import Data.HashTable (HashTable)-import qualified Data.HashTable as H+import Data.Hashable+import qualified Data.HashTable.IO as H import Data.Int (Int32, Int64) import Data.IORef import Data.Map (Map)@@ -47,6 +49,8 @@ import Data.Typeable import qualified Codec.Compression.GZip as G +import qualified Agda.Compiler.Epic.Interface as Epic+ import Agda.Syntax.Common import Agda.Syntax.Concrete.Name as C import Agda.Syntax.Abstract.Name as A@@ -58,6 +62,7 @@ import Agda.Syntax.Fixity import Agda.Syntax.Notation import Agda.Syntax.Literal+import qualified Agda.Compiler.JS.Syntax as JS import qualified Agda.Interaction.Highlighting.Range   as HR import qualified Agda.Interaction.Highlighting.Precise as HP import Agda.Interaction.FindFile@@ -77,10 +82,21 @@ -- 32-bit machines). Word64 does not have these problems.  currentInterfaceVersion :: Word64-currentInterfaceVersion = 20110217 * 10 + 0+currentInterfaceVersion = 20111026 * 10 + 0 -type Node = [Int32] -- constructor tag (maybe omitted) and arg indices+-- | Constructor tag (maybe omitted) and argument indices. +type Node = [Int32]++-- | The type of hashtables used in this module.+--+-- A very limited amount of testing indicates that 'H.CuckooHashTable'+-- is somewhat slower than 'H.BasicHashTable', and that+-- 'H.LinearHashTable' and the hashtables from "Data.Hashtable" are+-- much slower.++type HashTable k v = H.BasicHashTable k v+ data Dict = Dict{ nodeD     :: !(HashTable Node    Int32)                 , stringD   :: !(HashTable String  Int32)                 , integerD  :: !(HashTable Integer Int32)@@ -93,8 +109,18 @@                 }  data U    = forall a . Typeable a => U !a-type Memo = HashTable (Int32, Int32) U    -- (node index, type rep key)+type Memo = HashTable (Int32, TypeRep') U    -- (node index, type rep) +-- | A newtype is used to avoid introducing an orphan instance of+-- Hashable.+newtype TypeRep' = TypeRep' { unTypeRep' :: TypeRep }+  deriving Eq++-- | With direct access to the internals of 'TypeRep' this instance+-- could presumably be improved.+instance Hashable TypeRep' where+  hash = hash . show . unTypeRep'+ data St = St   { nodeE     :: !(Array Int32 Node)   , stringE   :: !(Array Int32 String)@@ -141,7 +167,8 @@       nL <- l nD; sL <- l sD; iL <- l iD; dL <- l dD       return $ B.encode currentInterfaceVersion `L.append`                G.compress (B.encode (root, nL, sL, iL, dL))-  where l = fmap (List.map fst . List.sortBy (compare `on` snd)) . H.toList+  where+  l h = List.map fst . List.sortBy (compare `on` snd) <$> H.toList h  -- | Decodes something. The result depends on the include path. --@@ -173,7 +200,7 @@        else do          st <- St (ar nL) (ar sL) (ar iL) (ar dL)-                <$> liftIO (H.new (==) hashInt2)+                <$> liftIO H.new                 <*> return mf <*> return incs         (r, st) <- runStateT (runErrorT (value r)) st         return (Just (modFile st), case r of@@ -235,6 +262,11 @@   icode   = icodeX doubleD doubleC   value i = (! i) `fmap` gets doubleE +instance EmbPrj () where+  icode () = icode0'+  value = vcase valu where valu [] = valu0 ()+                           valu _  = malformed+ instance (EmbPrj a, EmbPrj b) => EmbPrj (a, b) where   icode (a, b) = icode2' a b   value = vcase valu where valu [a, b] = valu2 (,) a b@@ -253,10 +285,10 @@                            valu _   = malformed  instance EmbPrj Bool where-  icode True  = icode0 0-  icode False = icode0 1-  value = vcase valu where valu [0] = valu0 True-                           valu [1] = valu0 False+  icode True  = icode0'+  icode False = icode0 0+  value = vcase valu where valu []  = valu0 True+                           valu [0] = valu0 False                            valu _   = malformed  instance EmbPrj AbsolutePath where@@ -289,7 +321,7 @@  instance EmbPrj a => EmbPrj [a] where   icode xs = icodeN =<< mapM icode xs-  value = vcase $ mapM value+  value = vcase (mapM value) --   icode []       = icode0' --   icode (x : xs) = icode2' x xs --   value = vcase valu where valu []      = valu0 []@@ -321,10 +353,10 @@  instance EmbPrj C.Name where   icode (C.NoName a b) = icode2 0 a b-  icode (C.Name r xs)  = icode2 1 r xs-  value = vcase valu where valu [0, a, b]  = valu2 C.NoName a b-                           valu [1, r, xs] = valu2 C.Name   r xs-                           valu _          = malformed+  icode (C.Name r xs)  = icode2' r xs+  value = vcase valu where valu [0, a, b] = valu2 C.NoName a b+                           valu [r, xs]   = valu2 C.Name   r xs+                           valu _         = malformed  instance EmbPrj NamePart where   icode Hole   = icode0'@@ -341,15 +373,28 @@                            valu _      = malformed  instance EmbPrj Scope where-  icode (Scope a b c d e f) = icode6' a b c d e f-  value = vcase valu where valu [a, b, c, d, e, f] = valu6 Scope a b c d e f-                           valu _                  = malformed+  icode (Scope a b c d) = icode4' a b c d+  value = vcase valu where valu [a, b, c, d] = valu4 Scope a b c d+                           valu _            = malformed +instance EmbPrj NameSpaceId where+  icode PublicNS        = icode0'+  icode PrivateNS       = icode0 1+  icode ImportedNS      = icode0 2+  icode OnlyQualifiedNS = icode0 3+  value = vcase valu where valu []  = valu0 PublicNS+                           valu [1] = valu0 PrivateNS+                           valu [2] = valu0 ImportedNS+                           valu [3] = valu0 OnlyQualifiedNS+                           valu _   = malformed+ instance EmbPrj Access where   icode PrivateAccess = icode0 0-  icode PublicAccess  = icode0 1+  icode PublicAccess  = icode0'+  icode OnlyQualified = icode0 2   value = vcase valu where valu [0] = valu0 PrivateAccess-                           valu [1] = valu0 PublicAccess+                           valu []  = valu0 PublicAccess+                           valu [2] = valu0 OnlyQualified                            valu _   = malformed  instance EmbPrj NameSpace where@@ -367,19 +412,19 @@   value n = AbsModule `fmap` value n  instance EmbPrj KindOfName where-  icode DefName = icode0 0+  icode DefName = icode0'   icode ConName = icode0 1-  value = vcase valu where valu [0] = valu0 DefName+  value = vcase valu where valu []  = valu0 DefName                            valu [1] = valu0 ConName                            valu _   = malformed  instance EmbPrj Agda.Syntax.Fixity.Fixity where   icode (LeftAssoc  a b) = icode2 0 a b   icode (RightAssoc a b) = icode2 1 a b-  icode (NonAssoc   a b) = icode2 2 a b+  icode (NonAssoc   a b) = icode2' a b   value = vcase valu where valu [0, a, b] = valu2 LeftAssoc  a b                            valu [1, a, b] = valu2 RightAssoc a b-                           valu [2, a, b] = valu2 NonAssoc   a b+                           valu [a, b]    = valu2 NonAssoc   a b                            valu _         = malformed  instance EmbPrj Agda.Syntax.Fixity.Fixity' where@@ -390,10 +435,10 @@ instance EmbPrj GenPart where     icode (BindHole a)   = icode1 0 a     icode (NormalHole a) = icode1 1 a-    icode (IdPart a)     = icode1 2 a+    icode (IdPart a)     = icode1' a     value = vcase valu where valu [0, a] = valu1 BindHole a                              valu [1, a] = valu1 NormalHole a-                             valu [2, a] = valu1 IdPart a+                             valu [a]    = valu1 IdPart a                              valu _      = malformed  instance EmbPrj A.QName where@@ -443,26 +488,30 @@                            valu _         = malformed  instance EmbPrj Agda.Syntax.Common.Induction where-  icode Inductive   = icode0 0+  icode Inductive   = icode0'   icode CoInductive = icode0 1-  value = vcase valu where valu [0] = valu0 Inductive+  value = vcase valu where valu []  = valu0 Inductive                            valu [1] = valu0 CoInductive                            valu _   = malformed  instance EmbPrj Agda.Syntax.Common.Hiding where   icode Hidden    = icode0 0-  icode NotHidden = icode0 1+  icode NotHidden = icode0'+  icode Instance  = icode0 2   value = vcase valu where valu [0] = valu0 Hidden-                           valu [1] = valu0 NotHidden+                           valu []  = valu0 NotHidden+                           valu [2] = valu0 Instance                            valu _   = malformed  instance EmbPrj Agda.Syntax.Common.Relevance where-  icode Relevant   = icode0 0+  icode Relevant   = icode0'   icode Irrelevant = icode0 1   icode Forced     = icode0 2-  value = vcase valu where valu [0] = valu0 Relevant+  icode NonStrict  = icode0 3+  value = vcase valu where valu []  = valu0 Relevant                            valu [1] = valu0 Irrelevant                            valu [2] = valu0 Forced+                           valu [3] = valu0 NonStrict                            valu _   = malformed  instance EmbPrj I.Type where@@ -471,9 +520,11 @@                            valu _      = malformed  instance (EmbPrj a) => EmbPrj (I.Abs a) where-  icode (Abs a b) = icode2' a b-  value = vcase valu where valu [a, b] = valu2 Abs a b-                           valu _      = malformed+  icode (NoAbs a b) = icode2 0 a b+  icode (Abs a b)   = icode2' a b+  value = vcase valu where valu [a, b]    = valu2 Abs a b+                           valu [0, a, b] = valu2 NoAbs a b+                           valu _         = malformed  instance EmbPrj I.Term where   icode (Var      a b) = icode2 0 a b@@ -482,49 +533,62 @@   icode (Def      a b) = icode2 3 a b   icode (Con      a b) = icode2 4 a b   icode (Pi       a b) = icode2 5 a b-  icode (Fun      a b) = icode2 6 a b   icode (Sort     a  ) = icode1 7 a   icode (MetaV    a b) = __IMPOSSIBLE__-  icode (DontCare    ) = icode0 8+  icode (DontCare a  ) = icode1 8 a+  icode (Level    a  ) = icode1 9 a   value = vcase valu where valu [0, a, b] = valu2 Var   a b                            valu [1, a, b] = valu2 Lam   a b                            valu [2, a]    = valu1 Lit   a                            valu [3, a, b] = valu2 Def   a b                            valu [4, a, b] = valu2 Con   a b                            valu [5, a, b] = valu2 Pi    a b-                           valu [6, a, b] = valu2 Fun   a b                            valu [7, a]    = valu1 Sort  a-                           valu [8]       = valu0 DontCare+                           valu [8, a]    = valu1 DontCare a+                           valu [9, a]    = valu1 Level a                            valu _         = malformed +instance EmbPrj Level where+  icode (Max a) = icode1' a+  value = vcase valu where valu [a] = valu1 Max a+                           valu _   = malformed++instance EmbPrj PlusLevel where+  icode (ClosedLevel a) = icode1' a+  icode (Plus a b)      = icode2' a b+  value = vcase valu where valu [a]    = valu1 ClosedLevel a+                           valu [a, b] = valu2 Plus a b+                           valu _      = malformed++instance EmbPrj LevelAtom where+  icode (NeutralLevel a)   = icode1' a+  icode (UnreducedLevel a) = icode1 1 a+  icode MetaLevel{}        = __IMPOSSIBLE__+  icode BlockedLevel{}     = __IMPOSSIBLE__+  value = vcase valu where valu [a]    = valu1 NeutralLevel a+                           valu [1, a] = valu1 UnreducedLevel a+                           valu _      = malformed+ instance EmbPrj I.Sort where-  icode (Type  a  ) = icode1 0 a-  icode Prop        = icode0 1-  icode (Lub   a b) = icode2 2 a b-  icode (Suc   a  ) = icode1 3 a-  icode (MetaS a b) = __IMPOSSIBLE__-  icode Inf         = icode0 4-  icode (DLub a b)  = icode2 5 a b-  value = vcase valu where valu [0, a]    = valu1 Type  a-                           valu [1]       = valu0 Prop-                           valu [2, a, b] = valu2 Lub   a b-                           valu [3, a]    = valu1 Suc   a-                           valu [4]       = valu0 Inf-                           valu [5, a, b] = valu2 DLub a b-                           valu _         = malformed+  icode (Type  a  ) = icode1' a+  icode Prop        = icode1 1 ()+  icode Inf         = icode1 4 ()+  icode (DLub a b)  = __IMPOSSIBLE__+  value = vcase valu where valu [a]    = valu1 Type  a+                           valu [1, _] = valu0 Prop+                           valu [4, _] = valu0 Inf+                           valu _      = malformed  instance EmbPrj Agda.Syntax.Literal.Literal where-  icode (LitInt    a b) = icode2 0 a b+  icode (LitInt    a b) = icode2' a b   icode (LitFloat  a b) = icode2 1 a b   icode (LitString a b) = icode2 2 a b   icode (LitChar   a b) = icode2 3 a b-  icode (LitLevel  a b) = icode2 4 a b   icode (LitQName  a b) = icode2 5 a b-  value = vcase valu where valu [0, a, b] = valu2 LitInt    a b+  value = vcase valu where valu [a, b]    = valu2 LitInt    a b                            valu [1, a, b] = valu2 LitFloat  a b                            valu [2, a, b] = valu2 LitString a b                            valu [3, a, b] = valu2 LitChar   a b-                           valu [4, a, b] = valu2 LitLevel  a b                            valu [5, a, b] = valu2 LitQName  a b                            valu _         = malformed @@ -544,64 +608,122 @@  instance EmbPrj DisplayTerm where   icode (DTerm    a  ) = icode1' a-  icode (DWithApp a b) = icode2' a b-  value = vcase valu where valu [a]    = valu1 DTerm a-                           valu [a, b] = valu2 DWithApp a b-                           valu _      = malformed+  icode (DDot     a  ) = icode1 1 a+  icode (DCon     a b) = icode2 2 a b+  icode (DDef     a b) = icode2 3 a b+  icode (DWithApp a b) = icode2 4 a b+  value = vcase valu where valu [a]       = valu1 DTerm a+                           valu [1, a]    = valu1 DDot a+                           valu [2, a, b] = valu2 DCon a b+                           valu [3, a, b] = valu2 DDef a b+                           valu [4, a, b] = valu2 DWithApp a b+                           valu _         = malformed  instance EmbPrj MutualId where   icode (MutId a) = icode a   value n = MutId `fmap` value n  instance EmbPrj Definition where-  icode (Defn rel a b c d e) = icode6' rel a b c d e-  value = vcase valu where valu [rel, a, b, c, d, e] = valu6 Defn rel a b c d e-                           valu _                    = malformed+  icode (Defn rel a b c d e f) = icode7' rel a b c d e f+  value = vcase valu where valu [rel, a, b, c, d, e, f] = valu7 Defn rel a b c d e f+                           valu _                       = malformed  instance EmbPrj HaskellRepresentation where-  icode (HsType a)   = icode1 0 a-  icode (HsDefn a b) = icode2 1 a b+  icode (HsType a)   = icode1' a+  icode (HsDefn a b) = icode2' a b    value = vcase valu where-    valu [0, a]    = valu1 HsType a-    valu [1, a, b] = valu2 HsDefn a b-    valu _         = malformed+    valu [a]    = valu1 HsType a+    valu [a, b] = valu2 HsDefn a b+    valu _      = malformed +instance EmbPrj JS.Exp where+  icode (JS.Self)         = icode0 0+  icode (JS.Local i)      = icode1 1 i+  icode (JS.Global i)     = icode1 2 i+  icode (JS.Undefined)    = icode0 3+  icode (JS.String s)     = icode1 4 s+  icode (JS.Char c)       = icode1 5 c+  icode (JS.Integer n)    = icode1 6 n+  icode (JS.Double d)     = icode1 7 d+  icode (JS.Lambda n e)   = icode2 8 n e+  icode (JS.Object o)     = icode1 9 o+  icode (JS.Apply e es)   = icode2 10 e es+  icode (JS.Lookup e l)   = icode2 11 e l+  icode (JS.If e f g)     = icode3 12 e f g+  icode (JS.BinOp e op f) = icode3 13 e op f+  icode (JS.PreOp op e)   = icode2 14 op e+  icode (JS.Const i)      = icode1 15 i+  value = vcase valu where valu [0]           = valu0 JS.Self+                           valu [1,  a]       = valu1 JS.Local a+                           valu [2,  a]       = valu1 JS.Global a+                           valu [3]           = valu0 JS.Undefined+                           valu [4,  a]       = valu1 JS.String a+                           valu [5,  a]       = valu1 JS.Char a+                           valu [6,  a]       = valu1 JS.Integer a+                           valu [7,  a]       = valu1 JS.Double a+                           valu [8,  a, b]    = valu2 JS.Lambda a b+                           valu [9,  a]       = valu1 JS.Object a+                           valu [10, a, b]    = valu2 JS.Apply a b+                           valu [11, a, b]    = valu2 JS.Lookup a b+                           valu [12, a, b, c] = valu3 JS.If a b c+                           valu [13, a, b, c] = valu3 JS.BinOp a b c+                           valu [14, a, b]    = valu2 JS.PreOp a b+                           valu [15, a]       = valu1 JS.Const a+                           valu _             = malformed++instance EmbPrj JS.LocalId where+  icode (JS.LocalId l) = icode l+  value n = JS.LocalId `fmap` value n++instance EmbPrj JS.GlobalId where+  icode (JS.GlobalId l) = icode l+  value n = JS.GlobalId `fmap` value n++instance EmbPrj JS.MemberId where+  icode (JS.MemberId l) = icode l+  value n = JS.MemberId `fmap` value n+ instance EmbPrj Polarity where-  icode Covariant     = icode0 0+  icode Covariant     = icode0'   icode Contravariant = icode0 1   icode Invariant     = icode0 2    value = vcase valu where-    valu [0] = valu0 Covariant+    valu []  = valu0 Covariant     valu [1] = valu0 Contravariant     valu [2] = valu0 Invariant     valu _   = malformed  instance EmbPrj Occurrence where-  icode Positive = icode0 0+  icode Positive = icode0'   icode Negative = icode0 1   icode Unused   = icode0 2    value = vcase valu where-    valu [0] = valu0 Positive+    valu []  = valu0 Positive     valu [1] = valu0 Negative     valu [2] = valu0 Unused     valu _   = malformed +instance EmbPrj CompiledRepresentation where+  icode (CompiledRep a b c) = icode3' a b c+  value = vcase valu where valu [a, b, c] = valu3 CompiledRep a b c+                           valu _         = malformed+ instance EmbPrj Defn where-  icode (Axiom       a b)                   = icode2 0 a b-  icode (Function    a b c d e f g h)       = icode8 1 a b c d e f g h-  icode (Datatype    a b c d e f g h i j)   = icode10 2 a b c d e f g h i j+  icode Axiom                               = icode0 0+  icode (Function    a b c d e f g h i)     = icode9 1 a b c d e f g h i+  icode (Datatype    a b c d e f g h i)     = icode9 2 a b c d e f g h i   icode (Record      a b c d e f g h i j k) = icode11 3 a b c d e f g h i j k-  icode (Constructor a b c d e f)           = icode6 4 a b c d e f+  icode (Constructor a b c d e)             = icode5 4 a b c d e   icode (Primitive   a b c d)               = icode4 5 a b c d   value = vcase valu where-    valu [0, a, b]                            = valu2 Axiom       a b-    valu [1, a, b, c, d, e, f, g, h]          = valu8 Function    a b c d e f g h-    valu [2, a, b, c, d, e, f, g, h, i, j]    = valu10 Datatype   a b c d e f g h i j+    valu [0]                                  = valu0 Axiom+    valu [1, a, b, c, d, e, f, g, h, i]       = valu9 Function    a b c d e f g h i+    valu [2, a, b, c, d, e, f, g, h, i]       = valu9 Datatype    a b c d e f g h i     valu [3, a, b, c, d, e, f, g, h, i, j, k] = valu11 Record     a b c d e f g h i j k-    valu [4, a, b, c, d, e, f]                = valu6 Constructor a b c d e f+    valu [4, a, b, c, d, e]                   = valu5 Constructor a b c d e     valu [5, a, b, c, d]                      = valu4 Primitive   a b c d     valu _                                    = malformed @@ -613,13 +735,13 @@     valu _         = malformed  instance EmbPrj CompiledClauses where-  icode Fail       = icode0 0-  icode (Done a b) = icode2 1 a b+  icode Fail       = icode0'+  icode (Done a b) = icode2' a b   icode (Case a b) = icode2 2 a b    value = vcase valu where-    valu [0]       = valu0 Fail-    valu [1, a, b] = valu2 Done a b+    valu []        = valu0 Fail+    valu [a, b]    = valu2 Done a b     valu [2, a, b] = valu2 Case a b     valu _         = malformed @@ -631,26 +753,21 @@                            valu _   = malformed  instance EmbPrj TermHead where-  icode SortHead    = icode0 0+  icode SortHead    = icode0'   icode PiHead      = icode0 1   icode (ConHead a) = icode1 2 a-  value = vcase valu where valu [0]    = return SortHead-                           valu [1]    = return PiHead+  value = vcase valu where valu []     = valu0 SortHead+                           valu [1]    = valu0 PiHead                            valu [2, a] = valu1 ConHead a                            valu _      = malformed  instance EmbPrj Agda.Syntax.Common.IsAbstract where   icode AbstractDef = icode0 0-  icode ConcreteDef = icode0 1+  icode ConcreteDef = icode0'   value = vcase valu where valu [0] = valu0 AbstractDef-                           valu [1] = valu0 ConcreteDef+                           valu []  = valu0 ConcreteDef                            valu _   = malformed -instance EmbPrj I.Clauses where-  icode (Clauses a b) = icode2' a b-  value = vcase valu where valu [a, b] = valu2 Clauses a b-                           valu _      = malformed- instance EmbPrj I.Clause where   icode (Clause a b c d e) = icode5' a b c d e   value = vcase valu where valu [a, b, c, d, e] = valu5 Clause a b c d e@@ -658,42 +775,40 @@  instance EmbPrj I.ClauseBody where   icode (Body   a) = icode1 0 a-  icode (Bind   a) = icode1 1 a-  icode (NoBind a) = icode1 2 a+  icode (Bind   a) = icode1' a   icode NoBody     = icode0'   value = vcase valu where valu [0, a] = valu1 Body   a-                           valu [1, a] = valu1 Bind   a-                           valu [2, a] = valu1 NoBind a+                           valu [a]    = valu1 Bind   a                            valu []     = valu0 NoBody                            valu _      = malformed  instance EmbPrj Delayed where   icode Delayed    = icode0 0-  icode NotDelayed = icode0 1+  icode NotDelayed = icode0'   value = vcase valu where valu [0] = valu0 Delayed-                           valu [1] = valu0 NotDelayed+                           valu []  = valu0 NotDelayed                            valu _   = malformed  instance EmbPrj I.Pattern where-  icode (VarP a    ) = icode1 0 a-  icode (ConP a b c) = icode3 1 a b c+  icode (VarP a    ) = icode1' a+  icode (ConP a b c) = icode3' a b c   icode (LitP a    ) = icode1 2 a   icode (DotP a    ) = icode1 3 a-  value = vcase valu where valu [0, a]       = valu1 VarP a-                           valu [1, a, b, c] = valu3 ConP a b c-                           valu [2, a]       = valu1 LitP a-                           valu [3, a]       = valu1 DotP a-                           valu _            = malformed+  value = vcase valu where valu [a]       = valu1 VarP a+                           valu [a, b, c] = valu3 ConP a b c+                           valu [2, a]    = valu1 LitP a+                           valu [3, a]    = valu1 DotP a+                           valu _         = malformed  instance EmbPrj a => EmbPrj (Builtin a) where-  icode (Prim    a) = icode1 0 a+  icode (Prim    a) = icode1' a   icode (Builtin a) = icode1 1 a-  value = vcase valu where valu [0, a] = valu1 Prim    a+  value = vcase valu where valu [a]    = valu1 Prim    a                            valu [1, a] = valu1 Builtin a                            valu _      = malformed  instance EmbPrj HP.NameKind where-  icode HP.Bound           = icode0 0+  icode HP.Bound           = icode0'   icode (HP.Constructor a) = icode1 1 a   icode HP.Datatype        = icode0 2   icode HP.Field           = icode0 3@@ -704,7 +819,7 @@   icode HP.Record          = icode0 8    value = vcase valu where-    valu [0]     = valu0 HP.Bound+    valu []      = valu0 HP.Bound     valu [1 , a] = valu1 HP.Constructor a     valu [2]     = valu0 HP.Datatype     valu [3]     = valu0 HP.Field@@ -720,7 +835,7 @@   icode HP.Keyword       = icode0 1   icode HP.String        = icode0 2   icode HP.Number        = icode0 3-  icode HP.Symbol        = icode0 4+  icode HP.Symbol        = icode0'   icode HP.PrimitiveType = icode0 5   icode (HP.Name mk b)   = icode2 6 mk b @@ -729,21 +844,21 @@     valu [1]        = valu0 HP.Keyword     valu [2]        = valu0 HP.String     valu [3]        = valu0 HP.Number-    valu [4]        = valu0 HP.Symbol+    valu []         = valu0 HP.Symbol     valu [5]        = valu0 HP.PrimitiveType     valu [6, mk, b] = valu2 HP.Name mk b     valu _          = malformed  instance EmbPrj HP.OtherAspect where   icode HP.Error              = icode0 0-  icode HP.DottedPattern      = icode0 1+  icode HP.DottedPattern      = icode0'   icode HP.UnsolvedMeta       = icode0 2   icode HP.TerminationProblem = icode0 3   icode HP.IncompletePattern  = icode0 4    value = vcase valu where     valu [0] = valu0 HP.Error-    valu [1] = valu0 HP.DottedPattern+    valu []  = valu0 HP.DottedPattern     valu [2] = valu0 HP.UnsolvedMeta     valu [3] = valu0 HP.TerminationProblem     valu [4] = valu0 HP.IncompletePattern@@ -757,7 +872,7 @@     valu _            = malformed  instance EmbPrj Precedence where-  icode TopCtx                 = icode0 0+  icode TopCtx                 = icode0'   icode FunctionSpaceDomainCtx = icode0 1   icode (LeftOperandCtx a)     = icode1 2 a   icode (RightOperandCtx a)    = icode1 3 a@@ -769,7 +884,7 @@   icode DotPatternCtx          = icode0 9   value = vcase valu     where-    valu [0]    = valu0 TopCtx+    valu []     = valu0 TopCtx     valu [1]    = valu0 FunctionSpaceDomainCtx     valu [2, a] = valu1 LeftOperandCtx a     valu [3, a] = valu1 RightOperandCtx a@@ -791,45 +906,77 @@   value = vcase valu where valu [a, b, c, d, e, f, g, h, i] = valu9 Interface a b c d e f g h i                            valu _                           = malformed +-- This is used for the Epic compiler backend+instance EmbPrj Epic.EInterface where+  icode (Epic.EInterface a b c d e f g h) = icode8' a b c d e f g h+  value = vcase valu where+    valu [a, b, c, d, e, f, g, h] = valu8 Epic.EInterface a b c d e f g h+    valu _                        = malformed +instance EmbPrj Epic.InjectiveFun where+  icode (Epic.InjectiveFun a b) = icode2' a b+  value = vcase valu where+     valu [a,b] = valu2 Epic.InjectiveFun a b+     valu _     = malformed -icodeX :: (Dict -> HashTable k Int32) -> (Dict -> IORef Int32) ->+instance EmbPrj Epic.Relevance where+  icode Epic.Irr      = icode0 0+  icode Epic.Rel      = icode0 1+  value = vcase valu where valu [0] = valu0 Epic.Irr+                           valu [1] = valu0 Epic.Rel+                           valu _   = malformed++instance EmbPrj Epic.Forced where+  icode Epic.Forced    = icode0 0+  icode Epic.NotForced = icode0 1+  value = vcase valu where valu [0] = valu0 Epic.Forced+                           valu [1] = valu0 Epic.NotForced+                           valu _   = malformed++instance EmbPrj Epic.Tag where+  icode (Epic.Tag a)     = icode1 0 a+  icode (Epic.PrimTag a) = icode1 1 a+  value = vcase valu+    where+    valu [0, a] = valu1 Epic.Tag a+    valu [1, a] = valu1 Epic.PrimTag a+    valu _      = malformed++{-# SPECIALIZE icodeX :: (Dict -> HashTable [Int32] Int32) ->+                         (Dict -> IORef Int32) -> [Int32] -> S Int32 #-}+icodeX :: (Eq k, Hashable k) =>+          (Dict -> HashTable k Int32) -> (Dict -> IORef Int32) ->           k -> S Int32 icodeX dict counter key = do-  d     <- asks dict-  c     <- asks counter-  fresh <- lift $ readIORef c-  mi    <- lift $ H.lookup d key+  d <- asks dict+  c <- asks counter+  liftIO $ do+  mi    <- H.lookup d key   case mi of     Just i  -> return i-    Nothing -> do lift $ H.insert d key fresh-                  lift $ writeIORef c (fresh + 1)-                  return fresh+    Nothing -> do+      fresh <- readIORef c+      H.insert d key fresh+      writeIORef c $! fresh + 1+      return fresh +icodeN :: [Int32] -> S Int32 icodeN = icodeX nodeD nodeC +{-# INLINE vcase #-} vcase :: forall a . EmbPrj a => (Node -> R a) -> Int32 -> R a-vcase valu ix = do+vcase valu = \ix -> do     memo <- gets nodeMemo     (aTyp, maybeU) <- liftIO $ do-      aTyp   <- typeRepKey $ typeOf (undefined :: a)-      -- The following tests try to ensure that conversion to Int32-      -- won't truncate the key. The tests can perhaps give erroneous-      -- results if Int is "larger" than Int64.-      when ((convert aTyp :: Int64) > convert (maxBound :: Int32)) __IMPOSSIBLE__-      when ((convert aTyp :: Int64) < convert (minBound :: Int32)) __IMPOSSIBLE__-      let aTyp' = convert aTyp :: Int32-      maybeU <- H.lookup memo (ix, aTyp')-      return (aTyp', maybeU)+      let aTyp = TypeRep' $ typeOf (undefined :: a)+      maybeU <- H.lookup memo (ix, aTyp)+      return (aTyp, maybeU)     case maybeU of       Just (U u) -> maybe malformed return (cast u)       Nothing    -> do           v <- valu . (! ix) =<< gets nodeE           liftIO $ H.insert memo (ix, aTyp) (U v)           return v-    where-    convert :: (Integral b, Integral c) => b -> c-    convert = fromInteger . toInteger  icode0  tag                       = icodeN [tag] icode1  tag a                     = icodeN . (tag :) =<< sequence [icode a]@@ -843,6 +990,7 @@ icode9  tag a b c d e f g h i     = icodeN . (tag :) =<< sequence [icode a, icode b, icode c, icode d, icode e, icode f, icode g, icode h, icode i] icode10 tag a b c d e f g h i j   = icodeN . (tag :) =<< sequence [icode a, icode b, icode c, icode d, icode e, icode f, icode g, icode h, icode i, icode j] icode11 tag a b c d e f g h i j k = icodeN . (tag :) =<< sequence [icode a, icode b, icode c, icode d, icode e, icode f, icode g, icode h, icode i, icode j, icode k]+icode12 tag a b c d e f g h i j k l = icodeN . (tag :) =<< sequence [icode a, icode b, icode c, icode d, icode e, icode f, icode g, icode h, icode i, icode j, icode k, icode l]  icode0'                        = icodeN [] icode1'  a                     = icodeN =<< sequence [icode a]@@ -856,19 +1004,21 @@ icode9'  a b c d e f g h i     = icodeN =<< sequence [icode a, icode b, icode c, icode d, icode e, icode f, icode g, icode h, icode i] icode10' a b c d e f g h i j   = icodeN =<< sequence [icode a, icode b, icode c, icode d, icode e, icode f, icode g, icode h, icode i, icode j] icode11' a b c d e f g h i j k = icodeN =<< sequence [icode a, icode b, icode c, icode d, icode e, icode f, icode g, icode h, icode i, icode j, icode k]+icode12' a b c d e f g h i j k l = icodeN =<< sequence [icode a, icode b, icode c, icode d, icode e, icode f, icode g, icode h, icode i, icode j, icode k, icode l] -valu0  z                       = return z-valu1  z a                     = valu0 z                      `ap` value a-valu2  z a b                   = valu1 z a                    `ap` value b-valu3  z a b c                 = valu2 z a b                  `ap` value c-valu4  z a b c d               = valu3 z a b c                `ap` value d-valu5  z a b c d e             = valu4 z a b c d              `ap` value e-valu6  z a b c d e f           = valu5 z a b c d e            `ap` value f-valu7  z a b c d e f g         = valu6 z a b c d e f          `ap` value g-valu8  z a b c d e f g h       = valu7 z a b c d e f g        `ap` value h-valu9  z a b c d e f g h i     = valu8 z a b c d e f g h      `ap` value i-valu10 z a b c d e f g h i j   = valu9 z a b c d e f g h i    `ap` value j-valu11 z a b c d e f g h i j k = valu10 z a b c d e f g h i j `ap` value k+valu0  z                         = return z+valu1  z a                       = valu0 z                        `ap` value a+valu2  z a b                     = valu1 z a                      `ap` value b+valu3  z a b c                   = valu2 z a b                    `ap` value c+valu4  z a b c d                 = valu3 z a b c                  `ap` value d+valu5  z a b c d e               = valu4 z a b c d                `ap` value e+valu6  z a b c d e f             = valu5 z a b c d e              `ap` value f+valu7  z a b c d e f g           = valu6 z a b c d e f            `ap` value g+valu8  z a b c d e f g h         = valu7 z a b c d e f g          `ap` value h+valu9  z a b c d e f g h i       = valu8 z a b c d e f g h        `ap` value i+valu10 z a b c d e f g h i j     = valu9 z a b c d e f g h i      `ap` value j+valu11 z a b c d e f g h i j k   = valu10 z a b c d e f g h i j   `ap` value k+valu12 z a b c d e f g h i j k l = valu11 z a b c d e f g h i j k `ap` value l  -- | Creates an empty dictionary. @@ -878,27 +1028,12 @@              -- later encountered.           -> IO Dict emptyDict fileMod = Dict-  <$> H.new (==) hashNode-  <*> H.new (==) H.hashString-  <*> H.new (==) (H.hashInt . fromIntegral)-  <*> H.new (==) (H.hashInt . floor)+  <$> H.new+  <*> H.new+  <*> H.new+  <*> H.new   <*> newIORef 0   <*> newIORef 0   <*> newIORef 0   <*> newIORef 0   <*> return fileMod--hashNode :: Node -> Int32-hashNode is = List.foldl' f golden is-   where f m c = fromIntegral c * magic + hashInt32 m-         magic  = 0xdeadbeef-         golden :: Int32-         golden = 1013904242-         hashInt32 x = mulHi x golden + x-         mulHi :: Int32 -> Int32 -> Int32-         mulHi a b = fromIntegral (r `shiftR` 32)-             where r :: Int64-                   r = fromIntegral a * fromIntegral b--hashInt2 :: (Int32, Int32) -> Int32-hashInt2 (ix, rep) = hashNode [ix , rep]

src/full/Agda/TypeChecking/SizedTypes.hs view

@@ -17,6 +17,7 @@ import Agda.TypeChecking.Substitute import Agda.TypeChecking.Telescope import {-# SOURCE #-} Agda.TypeChecking.Conversion+import Agda.TypeChecking.Constraints import qualified Agda.Utils.Warshall as W import Agda.Utils.List import Agda.Utils.Monad@@ -26,7 +27,7 @@ #include "../undefined.h"  -- | Compare two sizes. Only with --sized-types.-compareSizes :: MonadTCM tcm => Comparison -> Term -> Term -> tcm Constraints+compareSizes :: Comparison -> Term -> Term -> TCM () compareSizes cmp u v = do   reportSDoc "tc.conv.size" 10 $ vcat     [ text "Comparing sizes"@@ -44,18 +45,18 @@   s2   <- sizeView v   size <- sizeType   case (cmp, s1, s2) of-    (CmpLeq, _,         SizeInf)   -> return []+    (CmpLeq, _,         SizeInf)   -> return ()     (CmpLeq, SizeInf,   _)         -> compareSizes CmpEq u v     (CmpEq,  SizeSuc u, SizeInf)   -> compareSizes CmpEq u v     (_,      SizeInf,   SizeSuc v) -> compareSizes CmpEq u v     (_,      SizeSuc u, SizeSuc v) -> compareSizes cmp u v     (CmpLeq, _,         _)         ->-      ifM (trivial u v) (return []) $-        buildConstraint $ ValueCmp CmpLeq size u v-    _                              -> compareAtom cmp size u v+      ifM (trivial u v) (return ()) $+        addConstraint $ ValueCmp CmpLeq size u v+    _ -> compareAtom cmp size u v -trivial :: MonadTCM tcm => Term -> Term -> tcm Bool-trivial u v = liftTCM $ do+trivial :: Term -> Term -> TCM Bool+trivial u v = do     a <- sizeExpr u     b <- sizeExpr v     reportSDoc "tc.conv.size" 15 $@@ -68,19 +69,17 @@   `catchError` \_ -> return False  -- | Find the size constraints.-getSizeConstraints :: MonadTCM tcm => tcm [SizeConstraint]+getSizeConstraints :: TCM [SizeConstraint] getSizeConstraints = do-  cs   <- getConstraints+  cs   <- getAllConstraints   size <- sizeType   let sizeConstraints cl@(Closure{ clValue = ValueCmp CmpLeq s _ _ })         | s == size = [cl]-      sizeConstraints cl@(Closure{ clValue = Guarded _ cs }) =-        concatMap sizeConstraints cs       sizeConstraints _ = []-  scs <- mapM computeSizeConstraint $ concatMap sizeConstraints cs+  scs <- mapM computeSizeConstraint $ concatMap (sizeConstraints . theConstraint) cs   return [ c | Just c <- scs ] -getSizeMetas :: MonadTCM tcm => tcm [(MetaId, Int)]+getSizeMetas :: TCM [(MetaId, Int)] getSizeMetas = do   ms <- getOpenMetas   sz <- sizeType@@ -111,8 +110,8 @@     | n > 0     = show a ++ " =< " ++ show b ++ " + " ++ show n     | otherwise = show a ++ " + " ++ show (-n) ++ " =< " ++ show b -computeSizeConstraint :: MonadTCM tcm => ConstraintClosure -> tcm (Maybe SizeConstraint)-computeSizeConstraint cl = liftTCM $+computeSizeConstraint :: Closure Constraint -> TCM (Maybe SizeConstraint)+computeSizeConstraint cl =   enterClosure cl $ \c ->     case c of       ValueCmp CmpLeq _ u v -> do@@ -125,7 +124,7 @@       _ -> __IMPOSSIBLE__  -- | Throws a 'patternViolation' if the term isn't a proper size expression.-sizeExpr :: MonadTCM tcm => Term -> tcm (SizeExpr, Int)+sizeExpr :: Term -> TCM (SizeExpr, Int) sizeExpr u = do   u <- reduce u -- Andreas, 2009-02-09.                 -- This is necessary to surface the solutions of metavariables.@@ -154,15 +153,15 @@     flex (Rigid _)       = []     flex (SizeMeta m xs) = [(m, xs)] -haveSizedTypes :: MonadTCM tcm => tcm Bool-haveSizedTypes = liftTCM $ do+haveSizedTypes :: TCM Bool+haveSizedTypes = do     Def _ [] <- primSize     Def _ [] <- primSizeInf     Def _ [] <- primSizeSuc     optSizedTypes <$> pragmaOptions   `catchError` \_ -> return False -solveSizeConstraints :: MonadTCM tcm => tcm ()+solveSizeConstraints :: TCM () solveSizeConstraints = whenM haveSizedTypes $ do   cs <- getSizeConstraints   ms <- getSizeMetas@@ -194,9 +193,7 @@   verboseS "tc.size.solve" 20 $ do     let meta (m, _) = do           j <- mvJudgement <$> lookupMeta m-          reportSDoc "" 0 $ case j of-            HasType _ t -> text (show m) <+> text ":" <+> prettyTCM t-            IsSort _    -> text (show m) <+> text "sort"+          reportSDoc "" 0 $ prettyTCM j     mapM_ meta metas    case W.solve $ map mkFlex metas ++ map mkConstr cs of@@ -232,7 +229,7 @@               , nest 2 $ prettyTCM v               ] -            m =: v+            assignTerm m v        mapM_ inst $ Map.toList sol

src/full/Agda/TypeChecking/Substitute.hs view

@@ -1,9 +1,15 @@-{-# LANGUAGE CPP, TypeSynonymInstances #-}+{-# LANGUAGE CPP, TypeSynonymInstances, FlexibleInstances,+    DeriveDataTypeable, DeriveFunctor, StandaloneDeriving #-} module Agda.TypeChecking.Substitute where  import Control.Monad.Identity import Control.Monad.Reader+import Control.Arrow ((***))++import Data.Generics (Typeable, Data) import Data.List hiding (sort)+import qualified Data.List as List+import Data.Function import Data.Map (Map) import qualified Data.Map as Map import qualified Data.Set as Set@@ -36,11 +42,12 @@             Con c args'   -> Con c (args' ++ args)             Lam _ u       -> absApp u (unArg a) `apply` args0             MetaV x args' -> MetaV x (args' ++ args)-            Lit l         -> __IMPOSSIBLE__+            Lit{}         -> __IMPOSSIBLE__+            Level{}       -> __IMPOSSIBLE__             Pi _ _        -> __IMPOSSIBLE__-            Fun _ _       -> __IMPOSSIBLE__             Sort _        -> __IMPOSSIBLE__-            DontCare      -> __IMPOSSIBLE__+            DontCare mv   -> DontCare $ mv `apply` args  -- Andreas, 2011-10-02+              -- need to go under DontCare, since "with" might resurrect irrelevant term  instance Apply Type where   apply = piApply@@ -55,23 +62,41 @@   apply (ExtendTel _ tel) (t : ts) = absApp tel (unArg t) `apply` ts  instance Apply Definition where-    apply (Defn rel x t df m d) args = Defn rel x (piApply t args) df m (apply d args)+    apply (Defn rel x t df m c d) args = Defn rel x (piApply t args) df m c (apply d args)  instance Apply Defn where+  apply d [] = d   apply d args = case d of     Axiom{} -> d     Function{ funClauses = cs, funCompiled = cc, funInv = inv-            , funProjection = mn } ->+            , funProjection = Nothing, funArgOccurrences = occ } ->       d { funClauses    = apply cs args         , funCompiled   = apply cc args         , funInv        = apply inv args-        , funProjection = fmap (nonNeg . \ n -> n - size args) mn-        } where nonNeg n = if n >= 0 then n else __IMPOSSIBLE__-    Datatype{ dataPars = np, dataClause = cl } ->-      d { dataPars = np - size args, dataClause = apply cl args }-    Record{ recPars = np, recConType = t, recClause = cl, recTel = tel } ->+        , funArgOccurrences = drop (length args) occ+        }+    Function{ funClauses = cs, funCompiled = cc, funInv = inv+            , funProjection = Just (r, n), funArgOccurrences = occ }+      | m < n  -> d { funProjection = Just (r, n - m) }+      | otherwise ->+        d { funClauses        = apply cs args'+          , funCompiled       = apply cc args'+          , funInv            = apply inv args'+          , funProjection     = Just (r, 0)+          , funArgOccurrences = drop 1 occ+          }+      where args' = [last args]+            m = size args+    Datatype{ dataPars = np, dataClause = cl+            , dataArgOccurrences = occ } ->+      d { dataPars = np - size args, dataClause = apply cl args+        , dataArgOccurrences = drop (length args) occ+        }+    Record{ recPars = np, recConType = t, recClause = cl, recTel = tel+          , recArgOccurrences = occ } ->       d { recPars = np - size args, recConType = apply t args         , recClause = apply cl args, recTel = apply tel args+        , recArgOccurrences = drop (length args) occ         }     Constructor{ conPars = np } ->       d { conPars = np - size args }@@ -81,10 +106,6 @@ instance Apply PrimFun where     apply (PrimFun x ar def) args   = PrimFun x (ar - size args) $ \vs -> def (args ++ vs) -instance Apply Clauses where-    apply (Clauses c tc) args =-      Clauses (apply c args) (apply tc args)- instance Apply Clause where     apply (Clause r tel perm ps b) args =       Clause r (apply tel args) (apply perm args)@@ -93,10 +114,11 @@ instance Apply CompiledClauses where   apply cc args = case cc of     Fail     -> Fail-    Done m t-      | m >= len  -> Done (m - len) (substs ([ Var (fromIntegral i) []-                                             | i <- [0..m - len - 1]] ++-                                             map unArg args) t)+    Done hs t+      | length hs >= len -> Done (drop len hs)+                                 (substs ([ Var (fromIntegral i) []+                                          | i <- [0..length hs - len - 1]] +++                                          map unArg args) t)       | otherwise -> __IMPOSSIBLE__     Case n bs       | n >= len  -> Case (n - len) (apply bs args)@@ -113,14 +135,17 @@   apply (Inverse inv) args = Inverse $ apply inv args  instance Apply ClauseBody where-    apply  b               []       = b-    apply (Bind (Abs _ b)) (a:args) = subst (unArg a) b `apply` args-    apply (NoBind b)       (_:args) = b `apply` args-    apply (Body _)         (_:_)    = __IMPOSSIBLE__-    apply  NoBody           _       = NoBody+    apply  b                 []       = b+    apply (Bind (Abs   _ b)) (a:args) = subst (unArg a) b `apply` args+    apply (Bind (NoAbs _ b)) (_:args) = b `apply` args+    apply (Body _)           (_:_)    = __IMPOSSIBLE__+    apply  NoBody             _       = NoBody  instance Apply DisplayTerm where   apply (DTerm v)          args = DTerm $ apply v args+  apply (DDot v)           args = DDot  $ apply v args+  apply (DCon c vs)        args = DCon c $ vs ++ map (fmap DTerm) args+  apply (DDef c vs)        args = DDef c $ vs ++ map (fmap DTerm) args   apply (DWithApp v args') args = DWithApp v $ args' ++ args  instance Apply t => Apply [t] where@@ -157,7 +182,6 @@ piApply :: Type -> Args -> Type piApply t []                      = t piApply (El _ (Pi  _ b)) (a:args) = absApp b (unArg a) `piApply` args-piApply (El _ (Fun _ b)) (_:args) = b `piApply` args piApply _ _                       = __IMPOSSIBLE__  -- | @(abstract args v) args --> v[args]@.@@ -179,23 +203,29 @@   abstract (ExtendTel arg tel') tel = ExtendTel arg $ fmap (`abstract` tel) tel'  instance Abstract Definition where-    abstract tel (Defn rel x t df m d) = Defn rel x (abstract tel t) df m (abstract tel d)+    abstract tel (Defn rel x t df m c d) = Defn rel x (abstract tel t) df m c (abstract tel d)  instance Abstract Defn where   abstract tel d = case d of     Axiom{} -> d     Function{ funClauses = cs, funCompiled = cc, funInv = inv-            , funProjection = mn } ->+            , funProjection = Nothing, funArgOccurrences = occ } ->       d { funClauses = abstract tel cs, funCompiled = abstract tel cc         , funInv = abstract tel inv-        , funProjection = fmap ((+) (size tel)) mn-          -- index of record arg shifts back by number of new args+        , funArgOccurrences = replicate (size tel) Negative ++ occ -- TODO: check occurrence         }-    Datatype{ dataPars = np, dataClause = cl } ->-      d { dataPars = np + size tel, dataClause = abstract tel cl }-    Record{ recPars = np, recConType = t, recClause = cl, recTel = tel' } ->+    Function{ funClauses = cs, funCompiled = cc, funInv = inv+            , funProjection = Just (r, n), funArgOccurrences = occ } ->+      d { funProjection = Just (r, n + size tel) }+    Datatype{ dataPars = np, dataClause = cl, dataArgOccurrences = occ } ->+      d { dataPars = np + size tel, dataClause = abstract tel cl+        , dataArgOccurrences = replicate (size tel) Negative ++ occ -- TODO: check occurrence+        }+    Record{ recPars = np, recConType = t, recClause = cl, recTel = tel'+          , recArgOccurrences = occ } ->       d { recPars = np + size tel, recConType = abstract tel t         , recClause = abstract tel cl, recTel = abstract tel tel'+        , recArgOccurrences = replicate (size tel) Negative ++ occ -- TODO: check occurrence         }     Constructor{ conPars = np } ->       d { conPars = np + size tel }@@ -206,10 +236,6 @@     abstract tel (PrimFun x ar def) = PrimFun x (ar + n) $ \ts -> def $ genericDrop n ts         where n = size tel -instance Abstract Clauses where-  abstract tel (Clauses c tc) =-    Clauses (abstract tel c) (abstract tel tc)- instance Abstract Clause where   abstract tel (Clause r tel' perm ps b) =     Clause r (abstract tel tel') (abstract tel perm)@@ -217,7 +243,7 @@  instance Abstract CompiledClauses where   abstract tel Fail = Fail-  abstract tel (Done m t) = Done (m + fromIntegral (size tel)) t+  abstract tel (Done xs t) = Done (map (fmap fst) (telToList tel) ++ xs) t   abstract tel (Case n bs) =     Case (n + fromIntegral (size tel)) (abstract tel bs) @@ -226,7 +252,7 @@     Branches (abstract tel cs) (abstract tel ls) (abstract tel m)  telVars EmptyTel                    = []-telVars (ExtendTel arg (Abs x tel)) = fmap (const $ VarP x) arg : telVars tel+telVars (ExtendTel arg tel) = fmap (const $ VarP $ absName tel) arg : telVars (unAbs tel)  instance Abstract FunctionInverse where   abstract tel NotInjective  = NotInjective@@ -271,16 +297,16 @@ instance Subst Term where     substs us t =         case t of-            Var i vs   -> (us !!! i) `apply` substs us vs-            Lam h m    -> Lam h $ substs us m-            Def c vs   -> Def c $ substs us vs-            Con c vs   -> Con c $ substs us vs-            MetaV x vs -> MetaV x $ substs us vs-            Lit l      -> Lit l-            Pi a b     -> uncurry Pi $ substs us (a,b)-            Fun a b    -> uncurry Fun $ substs us (a,b)-            Sort s     -> Sort $ substs us s-            DontCare   -> DontCare+            Var i vs    -> (us !!! i) `apply` substs us vs+            Lam h m     -> Lam h $ substs us m+            Def c vs    -> Def c $ substs us vs+            Con c vs    -> Con c $ substs us vs+            MetaV x vs  -> MetaV x $ substs us vs+            Lit l       -> Lit l+            Level l     -> levelTm $ substs us l+            Pi a b      -> uncurry Pi $ substs us (a,b)+            Sort s      -> sortTm $ substs us s+            DontCare mv -> DontCare $ substs us mv         where             []     !!! n = __IMPOSSIBLE__             (x:xs) !!! 0 = x@@ -295,11 +321,11 @@             Def c vs   -> Def c $ substUnder n u vs             Con c vs   -> Con c $ substUnder n u vs             MetaV x vs -> MetaV x $ substUnder n u vs+            Level l    -> levelTm $ substUnder n u l             Lit l      -> Lit l             Pi a b     -> uncurry Pi $ substUnder n u (a,b)-            Fun a b    -> uncurry Fun $ substUnder n u (a,b)-            Sort s     -> Sort $ substUnder n u s-            DontCare   -> DontCare+            Sort s     -> sortTm $ substUnder n u s+            DontCare mv -> DontCare $ substUnder n u mv  instance Subst Type where     substs us (El s t) = substs us s `El` substs us t@@ -307,25 +333,39 @@  instance Subst Sort where     substs us s = case s of-      Type n     -> Type $ sub n+      Type n     -> levelSort $ sub n       Prop       -> Prop-      Suc s      -> Suc $ sub s-      Lub s1 s2  -> Lub (sub s1) (sub s2)-      MetaS m as -> MetaS m (sub as)       Inf        -> Inf       DLub s1 s2 -> DLub (sub s1) (sub s2)       where sub x = substs us x      substUnder n u s = case s of-      Type n     -> Type $ sub n+      Type n     -> levelSort $ sub n       Prop       -> Prop-      Suc s      -> Suc $ sub s-      Lub s1 s2  -> Lub (sub s1) (sub s2)-      MetaS m as -> MetaS m (sub as)       Inf        -> Inf       DLub s1 s2 -> DLub (sub s1) (sub s2)       where sub x = substUnder n u x +instance Subst Level where+  substs us (Max as) = Max $ substs us as+  substUnder n u (Max as) = Max $ substUnder n u as++instance Subst PlusLevel where+  substs us l@ClosedLevel{} = l+  substs us (Plus n l) = Plus n $ substs us l+  substUnder n u l@ClosedLevel{} = l+  substUnder n u (Plus m l) = Plus m $ substUnder n u l++instance Subst LevelAtom where+  substs us      (MetaLevel m vs)   = MetaLevel m    $ substs us vs+  substs us      (BlockedLevel m v) = BlockedLevel m $ substs us v+  substs us      (NeutralLevel v)   = UnreducedLevel $ substs us v+  substs us      (UnreducedLevel v) = UnreducedLevel $ substs us v+  substUnder n u (MetaLevel m vs)   = MetaLevel m    $ substUnder n u vs+  substUnder n u (BlockedLevel m v) = BlockedLevel m $ substUnder n u v+  substUnder n u (NeutralLevel v)   = UnreducedLevel $ substUnder n u v+  substUnder n u (UnreducedLevel v) = UnreducedLevel $ substUnder n u v+ instance Subst Pattern where   substs us p = case p of     VarP s       -> VarP s@@ -344,8 +384,14 @@  instance Subst DisplayTerm where   substs us      (DTerm v)        = DTerm $ substs us v+  substs us      (DDot v)         = DDot  $ substs us v+  substs us      (DCon c vs)      = DCon c $ substs us vs+  substs us      (DDef c vs)      = DDef c $ substs us vs   substs us      (DWithApp vs ws) = uncurry DWithApp $ substs us (vs, ws)   substUnder n u (DTerm v)        = DTerm $ substUnder n u v+  substUnder n u (DDot  v)        = DDot  $ substUnder n u v+  substUnder n u (DCon c vs)      = DCon c $ substUnder n u vs+  substUnder n u (DDef c vs)      = DDef c $ substUnder n u vs   substUnder n u (DWithApp vs ws) = uncurry DWithApp $ substUnder n u (vs, ws)  instance Subst a => Subst (Tele a) where@@ -355,8 +401,10 @@   substUnder n u (ExtendTel t tel) = uncurry ExtendTel $ substUnder n u (t, tel)  instance Subst a => Subst (Abs a) where-    substs us      (Abs x t) = Abs x $ substs (Var 0 [] : raise 1 us) t-    substUnder n u (Abs x t) = Abs x $ substUnder (n + 1) u t+    substs us      (Abs   x t) = Abs   x $ substs (Var 0 [] : raise 1 us) t+    substs us      (NoAbs x t) = NoAbs x $ substs us t+    substUnder n u (Abs   x t) = Abs   x $ substUnder (n + 1) u t+    substUnder n u (NoAbs x t) = NoAbs x $ substUnder n u t  instance Subst a => Subst (Arg a) where     substs us      = fmap (substs us)@@ -377,21 +425,20 @@ instance Subst ClauseBody where     substs us (Body t)        = Body $ substs us t     substs us (Bind b)        = Bind $ substs us b-    substs us (NoBind b)      = NoBind $ substs us b     substs _   NoBody         = NoBody     substUnder n u (Body t)   = Body $ substUnder n u t     substUnder n u (Bind b)   = Bind $ substUnder n u b-    substUnder n u (NoBind b) = NoBind $ substUnder n u b     substUnder _ _   NoBody   = NoBody --- | Instantiate an abstraction-absApp :: Subst t => Abs t -> Term -> t-absApp (Abs _ v) u = subst u v- -- | Add @k@ to index of each open variable in @x@. class Raise t where     raiseFrom :: Nat -> Nat -> t -> t+    renameFrom :: Nat -> (Nat -> Nat) -> t -> t +instance Raise () where+  raiseFrom  _ _ _ = ()+  renameFrom _ _ _ = ()+ instance Raise Term where     raiseFrom m k v =         case v of@@ -402,28 +449,120 @@             Def c vs        -> Def c $ rf vs             Con c vs        -> Con c $ rf vs             MetaV x vs      -> MetaV x $ rf vs+            Level l         -> Level $ rf l             Lit l           -> Lit l             Pi a b          -> uncurry Pi $ rf (a,b)-            Fun a b         -> uncurry Fun $ rf (a,b)             Sort s          -> Sort $ rf s-            DontCare        -> DontCare+            DontCare mv     -> DontCare $ rf mv         where             rf x = raiseFrom m k x +    renameFrom m k v =+        case v of+            Var i vs+                | i < m     -> Var i $ rf vs+                | otherwise -> Var (k (i - m) + m) $ rf vs+            Lam h m         -> Lam h $ rf m+            Def c vs        -> Def c $ rf vs+            Con c vs        -> Con c $ rf vs+            MetaV x vs      -> MetaV x $ rf vs+            Level l         -> Level $ rf l+            Lit l           -> Lit l+            Pi a b          -> uncurry Pi $ rf (a,b)+            Sort s          -> Sort $ rf s+            DontCare mv     -> DontCare $ rf mv+        where+            rf x = renameFrom m k x+ instance Raise Type where     raiseFrom m k (El s t) = raiseFrom m k s `El` raiseFrom m k t+    renameFrom m k (El s t) = renameFrom m k s `El` renameFrom m k t  instance Raise Sort where     raiseFrom m k s = case s of       Type n     -> Type $ rf n       Prop       -> Prop-      Suc s      -> Suc $ rf s-      Lub s1 s2  -> Lub (rf s1) (rf s2)-      MetaS m as -> MetaS m (rf as)       Inf        -> Inf       DLub s1 s2 -> DLub (rf s1) (rf s2)       where rf x = raiseFrom m k x +    renameFrom m k s = case s of+      Type n     -> Type $ rf n+      Prop       -> Prop+      Inf        -> Inf+      DLub s1 s2 -> DLub (rf s1) (rf s2)+      where rf x = renameFrom m k x++instance Raise Level where+  raiseFrom m k (Max as) = Max $ raiseFrom m k as+  renameFrom m k (Max as) = Max $ renameFrom m k as++instance Raise PlusLevel where+  raiseFrom m k l@ClosedLevel{} = l+  raiseFrom m k (Plus n l) = Plus n $ raiseFrom m k l+  renameFrom m k l@ClosedLevel{} = l+  renameFrom m k (Plus n l) = Plus n $ renameFrom m k l++instance Raise LevelAtom where+  raiseFrom m k l = case l of+    MetaLevel n vs   -> MetaLevel n $ raiseFrom m k vs+    NeutralLevel v   -> NeutralLevel $ raiseFrom m k v+    BlockedLevel n v -> BlockedLevel n $ raiseFrom m k v+    UnreducedLevel v -> UnreducedLevel $ raiseFrom m k v+  renameFrom m k l = case l of+    MetaLevel n vs   -> MetaLevel n $ renameFrom m k vs+    NeutralLevel v   -> NeutralLevel $ renameFrom m k v+    BlockedLevel n v -> BlockedLevel n $ renameFrom m k v+    UnreducedLevel v -> UnreducedLevel $ renameFrom m k v++instance Raise Constraint where+  raiseFrom m k c = case c of+    ValueCmp cmp a u v       -> ValueCmp cmp (rf a) (rf u) (rf v)+    ElimCmp ps a v e1 e2     -> ElimCmp ps (rf a) (rf v) (rf e1) (rf e2)+    TypeCmp cmp a b          -> TypeCmp cmp (rf a) (rf b)+    TelCmp a b cmp tel1 tel2 -> TelCmp (rf a) (rf b) cmp (rf tel1) (rf tel2)+    SortCmp cmp s1 s2        -> SortCmp cmp (rf s1) (rf s2)+    LevelCmp cmp l1 l2       -> LevelCmp cmp (rf l1) (rf l2)+    Guarded c cs             -> Guarded (rf c) cs+    IsEmpty a                -> IsEmpty (rf a)+    FindInScope{}            -> c+    UnBlock{}                -> c+    where+      rf x = raiseFrom m k x+  renameFrom m k c = case c of+    ValueCmp cmp a u v       -> ValueCmp cmp (rf a) (rf u) (rf v)+    ElimCmp ps a v e1 e2     -> ElimCmp ps (rf a) (rf v) (rf e1) (rf e2)+    TypeCmp cmp a b          -> TypeCmp cmp (rf a) (rf b)+    TelCmp a b cmp tel1 tel2 -> TelCmp (rf a) (rf b) cmp (rf tel1) (rf tel2)+    SortCmp cmp s1 s2        -> SortCmp cmp (rf s1) (rf s2)+    LevelCmp cmp l1 l2       -> LevelCmp cmp (rf l1) (rf l2)+    Guarded c cs             -> Guarded (rf c) cs+    IsEmpty a                -> IsEmpty (rf a)+    FindInScope{}            -> c+    UnBlock{}                -> c+    where+      rf x = renameFrom m k x++instance Raise Elim where+  raiseFrom m k e = case e of+    Apply v -> Apply (raiseFrom m k v)+    Proj{}  -> e+  renameFrom m k e = case e of+    Apply v -> Apply (renameFrom m k v)+    Proj{}  -> e++instance Raise ClauseBody where+  raiseFrom m k b = case b of+    Body v   -> Body $ rf v+    NoBody   -> NoBody+    Bind b   -> Bind $ rf b+    where rf x = raiseFrom m k x+  renameFrom m k b = case b of+    Body v   -> Body $ rf v+    NoBody   -> NoBody+    Bind b   -> Bind $ rf b+    where rf x = renameFrom m k x+ -- Andreas, 2010-09-09 raise dot patterns and type info embedded in a pattern instance Raise Pattern where     raiseFrom m k p = case p of@@ -431,66 +570,101 @@       ConP c mt ps -> ConP c (raiseFrom m k mt) (raiseFrom m k ps)       VarP x -> p       LitP l -> p+    renameFrom m k p = case p of+      DotP t -> DotP $ renameFrom m k t+      ConP c mt ps -> ConP c (renameFrom m k mt) (renameFrom m k ps)+      VarP x -> p+      LitP l -> p  instance Raise a => Raise (Tele a) where     raiseFrom m k EmptyTel          = EmptyTel     raiseFrom m k (ExtendTel a tel) = uncurry ExtendTel $ raiseFrom m k (a, tel)+    renameFrom m k EmptyTel          = EmptyTel+    renameFrom m k (ExtendTel a tel) = uncurry ExtendTel $ renameFrom m k (a, tel)  instance Raise DisplayForm where   raiseFrom m k (Display n ps v) = Display n (raiseFrom (m + 1) k ps)                                              (raiseFrom (m + n) k v)+  renameFrom m k (Display n ps v) = Display n (renameFrom (m + 1) k ps)+                                             (renameFrom (m + n) k v)  instance Raise DisplayTerm where   raiseFrom m k (DWithApp xs ys) = uncurry DWithApp $ raiseFrom m k (xs, ys)   raiseFrom m k (DTerm v)        = DTerm $ raiseFrom m k v+  raiseFrom m k (DDot  v)        = DDot  $ raiseFrom m k v+  raiseFrom m k (DCon c vs)      = DCon c $ raiseFrom m k vs+  raiseFrom m k (DDef c vs)      = DDef c $ raiseFrom m k vs+  renameFrom m k (DWithApp xs ys) = uncurry DWithApp $ renameFrom m k (xs, ys)+  renameFrom m k (DTerm v)        = DTerm $ renameFrom m k v+  renameFrom m k (DDot  v)        = DDot  $ renameFrom m k v+  renameFrom m k (DCon c vs)      = DCon c $ renameFrom m k vs+  renameFrom m k (DDef c vs)      = DDef c $ renameFrom m k vs  instance Raise t => Raise (Abs t) where-    raiseFrom m k = fmap (raiseFrom (m + 1) k)+    raiseFrom m k (Abs x v)   = Abs x $ raiseFrom (m + 1) k v+    raiseFrom m k (NoAbs x v) = NoAbs x $ raiseFrom m k v+    renameFrom m k (Abs x v)   = Abs x $ renameFrom (m + 1) k v+    renameFrom m k (NoAbs x v) = NoAbs x $ renameFrom m k v  instance Raise t => Raise (Arg t) where     raiseFrom m k = fmap (raiseFrom m k)+    renameFrom m k = fmap (renameFrom m k)  instance Raise t => Raise (Blocked t) where     raiseFrom m k = fmap (raiseFrom m k)+    renameFrom m k = fmap (renameFrom m k)  instance Raise t => Raise [t] where     raiseFrom m k = fmap (raiseFrom m k)+    renameFrom m k = fmap (renameFrom m k)  instance Raise t => Raise (Maybe t) where     raiseFrom m k = fmap (raiseFrom m k)+    renameFrom m k = fmap (renameFrom m k)  instance Raise v => Raise (Map k v) where     raiseFrom m k = fmap (raiseFrom m k)+    renameFrom m k = fmap (renameFrom m k)  instance (Raise a, Raise b) => Raise (a,b) where     raiseFrom m k (x,y) = (raiseFrom m k x, raiseFrom m k y)+    renameFrom m k (x,y) = (renameFrom m k x, renameFrom m k y)  raise :: Raise t => Nat -> t -> t raise = raiseFrom 0 -data TelView = TelV Telescope Type+rename :: Raise t => (Nat -> Nat) -> t -> t+rename = renameFrom 0 +data TelV a = TelV (Tele (Arg a)) a+  deriving (Typeable, Data, Show, Eq, Ord, Functor)++type TelView = TelV Type+-- data TelView = TelV Telescope Type++telFromList :: [Arg (String, Type)] -> Telescope+telFromList = foldr (\(Arg h r (x, a)) -> ExtendTel (Arg h r a) . Abs x) EmptyTel++telToList :: Telescope -> [Arg (String, Type)]+telToList EmptyTel = []+telToList (ExtendTel arg tel) = fmap ((,) $ absName tel) arg : telToList (absBody tel)+ telView' :: Type -> TelView telView' t = case unEl t of-  Pi a (Abs x b)  -> absV a x $ telView' b-  Fun a b         -> absV a "_" $ telView' (raise 1 b)-  _               -> TelV EmptyTel t+  Pi a b  -> absV a (absName b) $ telView' (absBody b)+  _       -> TelV EmptyTel t   where     absV a x (TelV tel t) = TelV (ExtendTel a (Abs x tel)) t  telePi :: Telescope -> Type -> Type telePi  EmptyTel         t = t-telePi (ExtendTel u tel) t = el $ fn u b+telePi (ExtendTel u tel) t = el $ Pi u (reAbs b)   where     el = El (dLub s1 s2)     b = fmap (flip telePi t) tel     s1 = getSort $ unArg u     s2 = fmap getSort b -    fn a b-      | 0 `freeIn` absBody b = Pi a b-      | otherwise            = Fun a $ absApp b __IMPOSSIBLE__- -- | Everything will be a pi. telePi_ :: Telescope -> Type -> Type telePi_  EmptyTel        t = t@@ -501,12 +675,174 @@     s1 = getSort $ unArg u     s2 = fmap getSort b +teleLam :: Telescope -> Term -> Term+teleLam  EmptyTel	  t = t+teleLam (ExtendTel u tel) t = Lam (argHiding u) $ flip teleLam t <$> tel++-- | Dependent least upper bound, to assign a level to expressions+--   like @forall i -> Set i@.+--+--   @dLub s1 \i.s2 = \omega@ if @i@ appears in the rigid variables of @s2@. dLub :: Sort -> Abs Sort -> Sort-dLub s1 s2-  | 0 `Set.member` rv = Inf-  | 0 `Set.member` fv = DLub s1 s2-  | otherwise         = sLub s1 (absApp s2 __IMPOSSIBLE__)+dLub s1 (NoAbs _ s2) = sLub s1 s2+dLub s1 b@(Abs _ s2) = case occurrence 0 $ freeVars s2 of+  Flexible      -> DLub s1 b+  NoOccurrence  -> sLub s1 (absApp b __IMPOSSIBLE__)+  StronglyRigid -> Inf+  WeaklyRigid   -> Inf++-- Functions on abstractions ----------------------------------------------+--   and things we couldn't do before we could define 'absBody'++-- | Instantiate an abstraction+absApp :: Subst t => Abs t -> Term -> t+absApp (Abs   _ v) u = subst u v+absApp (NoAbs _ v) _ = v++absBody :: Raise t => Abs t -> t+absBody (Abs   _ v) = v+absBody (NoAbs _ v) = raise 1 v++mkAbs :: (Raise a, Free a) => String -> a -> Abs a+mkAbs x v | 0 `freeIn` v = Abs x v+          | otherwise    = NoAbs x (raise (-1) v)++reAbs :: (Raise a, Free a) => Abs a -> Abs a+reAbs (NoAbs x v) = NoAbs x v+reAbs (Abs x v)   = mkAbs x v++deriving instance (Raise a, Eq a) => Eq (Tele a)+deriving instance (Raise a, Ord a) => Ord (Tele a)++deriving instance Eq Sort+deriving instance Ord Sort+deriving instance Eq Type+deriving instance Ord Type+deriving instance Ord Term+deriving instance Eq Level+deriving instance Ord Level+deriving instance Eq PlusLevel+deriving instance Ord LevelAtom+deriving instance Eq Elim+deriving instance Ord Elim++deriving instance Eq Constraint++instance Ord PlusLevel where+  compare ClosedLevel{} Plus{}            = LT+  compare Plus{} ClosedLevel{}            = GT+  compare (ClosedLevel n) (ClosedLevel m) = compare n m+  -- Compare on the atom first. Makes most sense for levelMax.+  compare (Plus n a) (Plus m b)           = compare (a,n) (b,m)++instance Eq LevelAtom where+  (==) = (==) `on` unLevelAtom++-- | Syntactic equality, ignores stuff below @DontCare@.+instance Eq Term where+  Var x vs   == Var x' vs'   = x == x' && vs == vs'+  Lam h v    == Lam h' v'    = h == h' && v  == v'+  Lit l      == Lit l'       = l == l'+  Def x vs   == Def x' vs'   = x == x' && vs == vs'+  Con x vs   == Con x' vs'   = x == x' && vs == vs'+  Pi a b     == Pi a' b'     = a == a' && b == b'+  Sort s     == Sort s'      = s == s'+  Level l    == Level l'     = l == l'+  MetaV m vs == MetaV m' vs' = m == m' && vs == vs'+  DontCare _ == DontCare _   = True+  _          == _            = False++instance (Raise a, Eq a) => Eq (Abs a) where+  NoAbs _ a == NoAbs _ b = a == b+  Abs   _ a == Abs   _ b = a == b+  a         == b         = absBody a == absBody b++instance (Raise a, Ord a) => Ord (Abs a) where+  NoAbs _ a `compare` NoAbs _ b = a `compare` b+  Abs   _ a `compare` Abs   _ b = a `compare` b+  a         `compare` b         = absBody a `compare` absBody b++-- Level stuff ------------------------------------------------------------++sLub :: Sort -> Sort -> Sort+sLub s Prop = s+sLub Prop s = s+sLub Inf _ = Inf+sLub _ Inf = Inf+sLub (Type (Max as)) (Type (Max bs)) = Type $ levelMax (as ++ bs)+sLub (DLub a b) c = DLub (sLub a c) b+sLub a (DLub b c) = DLub (sLub a b) c++lvlView :: Term -> Level+lvlView (Level l)       = l+lvlView (Sort (Type l)) = l+lvlView v               = Max [Plus 0 $ UnreducedLevel v]++levelMax :: [PlusLevel] -> Level+levelMax as0 = Max $ ns ++ List.sort bs   where-    vs = freeVars (absBody s2)-    fv = flexibleVars vs-    rv = rigidVars vs+    as = Prelude.concatMap expand as0+    ns = case [ n | ClosedLevel n <- as, n > 0 ] of+      []  -> []+      ns  -> [ ClosedLevel n | n <- [Prelude.maximum ns], n > leastB ]+    bs = subsume [ b | b@Plus{} <- as ]+    leastB | null bs   = 0+           | otherwise = Prelude.minimum [ n | Plus n _ <- bs ]++    expand l@ClosedLevel{} = [l]+    expand (Plus n l) = map (plus n) $ expand0 $ expandAtom l++    expand0 [] = [ClosedLevel 0]+    expand0 as = as++    expandAtom (BlockedLevel _ (Level (Max as)))       = as+    expandAtom (NeutralLevel   (Level (Max as)))       = as+    expandAtom (UnreducedLevel (Level (Max as)))       = as+    expandAtom (BlockedLevel _ (Sort (Type (Max as)))) = as+    expandAtom (NeutralLevel   (Sort (Type (Max as)))) = as+    expandAtom (UnreducedLevel (Sort (Type (Max as)))) = as+    expandAtom l                                       = [Plus 0 l]++    plus n (ClosedLevel m) = ClosedLevel (n + m)+    plus n (Plus m l)      = Plus (n + m) l++    subsume (ClosedLevel{} : _) = __IMPOSSIBLE__+    subsume [] = []+    subsume (Plus n a : bs)+      | not $ null ns = subsume bs+      | otherwise     = Plus n a : subsume [ b | b@(Plus _ a') <- bs, a /= a' ]+      where+        ns = [ m | Plus m a'  <- bs, a == a', m > n ]++sortTm :: Sort -> Term+sortTm (Type l) = Sort $ levelSort l+sortTm s        = Sort s++levelSort :: Level -> Sort+levelSort (Max as)+  | List.any isInf as = Inf+  where+    isInf ClosedLevel{}        = False+    isInf (Plus _ l)           = infAtom l+    infAtom (NeutralLevel a)   = infTm a+    infAtom (UnreducedLevel a) = infTm a+    infAtom MetaLevel{}        = False+    infAtom BlockedLevel{}     = False+    infTm (Sort Inf)           = True+    infTm _                    = False+levelSort l =+  case levelTm l of+    Sort s -> s+    _      -> Type l++levelTm :: Level -> Term+levelTm l =+  case l of+    Max [Plus 0 l] -> unLevelAtom l+    _              -> Level l++unLevelAtom (MetaLevel x vs)   = MetaV x vs+unLevelAtom (NeutralLevel v)   = v+unLevelAtom (UnreducedLevel v) = v+unLevelAtom (BlockedLevel _ v) = v+

src/full/Agda/TypeChecking/Telescope.hs view

@@ -3,8 +3,6 @@ module Agda.TypeChecking.Telescope where  import Control.Applicative-import Data.Set (Set)-import qualified Data.Set as Set import Data.List  import Agda.Syntax.Common@@ -18,13 +16,16 @@ import Agda.Utils.Permutation import Agda.Utils.Size import Agda.Utils.Tuple+import Agda.Utils.VarSet (VarSet)+import qualified Agda.Utils.VarSet as Set  #include "../undefined.h" import Agda.Utils.Impossible +-- TODO: use rename instead of substs -- | The permutation should permute the corresponding telescope. (left-to-right list)-rename :: Subst t => Permutation -> t -> t-rename p = substs (renaming p)+renameP :: Subst t => Permutation -> t -> t+renameP p = substs (renaming p)  -- | If @permute π : [a]Γ -> [a]Δ@, then @substs (renaming π) : Term Γ -> Term Δ@ renaming :: Permutation -> [Term]@@ -48,14 +49,17 @@  -- | Order a flattened telescope in the correct dependeny order: Γ -> --   Permutation (Γ -> Γ~)-reorderTel :: [Arg Type] -> Permutation-reorderTel tel = case topoSort comesBefore tel' of-  Nothing -> __IMPOSSIBLE__-  Just p  -> p+reorderTel :: [Arg Type] -> Maybe Permutation+reorderTel tel = topoSort comesBefore tel'   where     tel' = reverse $ zip [0..] $ reverse tel     (i, _) `comesBefore` (_, a) = i `freeIn` unEl (unArg a) -- a tiny bit unsafe +reorderTel_ :: [Arg Type] -> Permutation+reorderTel_ tel = case reorderTel tel of+  Nothing -> __IMPOSSIBLE__+  Just p  -> p+ -- | Unflatten: turns a flattened telescope into a proper telescope. Must be --   properly ordered. unflattenTel :: [String] -> [Arg Type] -> Telescope@@ -89,7 +93,7 @@  -- | Split a telescope into the part that defines the given variables and the --   part that doesn't.-splitTelescope :: Set Nat -> Telescope -> SplitTel+splitTelescope :: VarSet -> Telescope -> SplitTel splitTelescope fv tel = SplitTel tel1 tel2 perm   where     names = teleNames tel@@ -103,11 +107,11 @@     isC   = [0..n - 1] \\ is     perm0 = Perm n $ is ++ isC -    permuteTel p ts = rename (reverseP p) (permute p ts)+    permuteTel p ts = renameP (reverseP p) (permute p ts)      ts1   = permuteTel perm0 ts0 -    perm1 = reorderTel ts1+    perm1 = reorderTel_ ts1      ts2   = permuteTel perm1 ts1 @@ -119,43 +123,27 @@     m         = genericLength $ takeWhile (`notElem` is) (reverse js)     (tel1, tel2) = telFromList -*- telFromList $ genericSplitAt (n - m) $ telToList tel' -{- Andreas 2010-10-01: this comment seems stale.  Where is the unsafe variant?--- | A safe variant of telView.--OLD CODE:-telView :: MonadTCM tcm => Type -> tcm TelView-telView t = do-  t <- reduce t-  case unEl t of-    Pi a (Abs x b) -> absV a x   <$> telView b-    Fun a b	   -> absV a "_" <$> telView (raise 1 b)-    _		   -> return $ TelV EmptyTel t-  where-    absV a x (TelV tel t) = TelV (ExtendTel a (Abs x tel)) t--}-telView :: MonadTCM tcm => Type -> tcm TelView+telView :: Type -> TCM TelView telView = telViewUpTo (-1)  -- | @telViewUpTo n t@ takes off the first @n@ function types of @t@. -- Takes off all if $n < 0$.-telViewUpTo :: MonadTCM tcm => Int -> Type -> tcm TelView+telViewUpTo :: Int -> Type -> TCM TelView telViewUpTo 0 t = return $ TelV EmptyTel t telViewUpTo n t = do   t <- reduce t   case unEl t of-    Pi a (Abs x b) -> absV a x   <$> telViewUpTo (n-1) b-    Fun a b	   -> absV a "_" <$> telViewUpTo (n-1) (raise 1 b)-    _		   -> return $ TelV EmptyTel t+    Pi a b -> absV a (absName b) <$> telViewUpTo (n - 1) (absBody b)+    _      -> return $ TelV EmptyTel t   where     absV a x (TelV tel t) = TelV (ExtendTel a (Abs x tel)) t  -- | A safe variant of piApply. -piApplyM :: MonadTCM tcm => Type -> Args -> tcm Type+piApplyM :: Type -> Args -> TCM Type piApplyM t []           = return t piApplyM t (arg : args) = do   t <- reduce t   case (t, arg) of     (El _ (Pi  _ b), arg) -> absApp b (unArg arg) `piApplyM` args-    (El _ (Fun _ b), _  ) -> b `piApplyM` args     _                     -> __IMPOSSIBLE__

src/full/Agda/TypeChecking/Test/Generators.hs view

@@ -8,7 +8,6 @@ import Control.Applicative import Control.Monad import Control.Monad.State-import qualified Data.Set as Set import qualified Data.List as List (sort, nub) import Agda.Utils.QuickCheck hiding (Args) @@ -23,6 +22,7 @@ import Agda.Utils.TestHelpers import Agda.Utils.Monad import Agda.Utils.QuickCheck hiding (Args)+import qualified Agda.Utils.VarSet as Set  #include "../../undefined.h" import Agda.Utils.Impossible@@ -252,7 +252,6 @@ 	, (sortF, Sort <$> genC conf) 	, (lamF,  genLam) 	, (piF,	  genPi)-	, (funF,  genFun) 	]     where       defs    = tcDefinedNames conf@@ -276,7 +275,6 @@ 	    | otherwise = freq (lamFreq  . termFreqs)       sortF = freq (sortFreq . termFreqs)       piF   = freq (piFreq   . termFreqs)-      funF  = freq (funFreq  . termFreqs)        genLam :: Gen Term       genLam = Lam <$> genC conf <*> genC (isntTypeConf $ decrConf conf)@@ -284,9 +282,6 @@       genPi :: Gen Term       genPi = uncurry Pi <$> genC conf -      genFun :: Gen Term-      genFun = uncurry Fun <$> genC conf-       genVar, genDef, genCon :: Gen Args -> Gen Term       genVar args = Var <$> elements vars <*> args       genDef args = Def <$> elements defs <*> args@@ -383,7 +378,6 @@ instance ShrinkC Literal Literal where   shrinkC _ (LitInt _ 0) = []   shrinkC conf l	 = LitInt noRange 0 : case l of-      LitLevel  r n -> LitLevel  r <$> shrink n       LitInt    r n -> LitInt    r <$> shrink n       LitString r s -> LitString r <$> shrinkC conf s       LitChar   r c -> LitChar   r <$> shrinkC conf c@@ -398,11 +392,13 @@  instance ShrinkC Hiding Hiding where   shrinkC _ Hidden    = [NotHidden]+  shrinkC _ Instance  = [Instance]   shrinkC _ NotHidden = []   noShrink = id  instance ShrinkC a b => ShrinkC (Abs a) (Abs b) where-  shrinkC conf (Abs s x) = Abs s <$> shrinkC (extendConf conf) x+  shrinkC conf (NoAbs s x) = NoAbs s <$> shrinkC conf x+  shrinkC conf (Abs   s x) = Abs s <$> shrinkC (extendConf conf) x   noShrink = fmap noShrink  instance ShrinkC a b => ShrinkC (Arg a) (Arg b) where@@ -419,10 +415,7 @@ instance ShrinkC Sort Sort where   shrinkC conf Prop = []   shrinkC conf s = Prop : case s of-    Type n     -> Type <$> shrinkC conf n-    Lub s1 s2  -> s1 : s2 : (uncurry Lub <$> shrinkC conf (s1, s2))-    Suc s      -> s : (Suc <$> shrinkC conf s)-    MetaS m _  -> []+    Type n     -> [] -- No Level instance yet -- Type <$> shrinkC conf n     Prop       -> __IMPOSSIBLE__     Inf        -> []     DLub s1 s2 -> __IMPOSSIBLE__@@ -439,9 +432,9 @@   noShrink = id  instance ShrinkC Term Term where-  shrinkC conf (DontCare)  = []+  shrinkC conf (DontCare _)  = []   shrinkC conf (Sort Prop) = []-  shrinkC conf t	   = filter validType $ DontCare : case t of+  shrinkC conf t	   = filter validType $ case t of     Var i args   -> map unArg args ++ 		    (uncurry Var <$> shrinkC conf (VarName i, NoType args))     Def d args   -> map unArg args ++@@ -449,14 +442,13 @@     Con d args   -> map unArg args ++ 		    (uncurry Con <$> shrinkC conf (ConName d, NoType args))     Lit l	 -> Lit <$> shrinkC conf l+    Level l      -> [] -- TODO     Lam h b      -> killAbs b : (uncurry Lam <$> shrinkC conf (h, b))     Pi a b       -> unEl (unArg a) : unEl (killAbs b) : 		    (uncurry Pi <$> shrinkC conf (a, b))-    Fun a b      -> unEl (unArg a) : unEl b :-		    (uncurry Fun <$> shrinkC conf (a, b))     Sort s       -> Sort <$> shrinkC conf s     MetaV m args -> map unArg args ++ (MetaV m <$> shrinkC conf (NoType args))-    DontCare     -> __IMPOSSIBLE__+    DontCare _   -> []     where       validType t 	| not (tcIsType conf) = True@@ -468,25 +460,26 @@   noShrink = id  killAbs :: KillVar a => Abs a -> a-killAbs (Abs _ x) = killVar 0 x+killAbs (Abs   _ x) = killVar 0 x+killAbs (NoAbs _ x) = x  class KillVar a where   killVar :: Nat -> a -> a  instance KillVar Term where   killVar i t = case t of-    Var j args | j == i	   -> DontCare+    Var j args | j == i	   -> DontCare (Var j []) 	       | j >  i	   -> Var (j - 1) $ killVar i args 	       | otherwise -> Var j	  $ killVar i args     Def c args		   -> Def c	  $ killVar i args     Con c args		   -> Con c	  $ killVar i args     Lit l		   -> Lit l+    Level l                -> Level l -- TODO     Sort s		   -> Sort s     Lam h b		   -> Lam h	  $ killVar i b     Pi a b		   -> uncurry Pi  $ killVar i (a, b)-    Fun a b		   -> uncurry Fun $ killVar i (a, b)     MetaV m args	   -> MetaV m	  $ killVar i args-    DontCare               -> DontCare+    DontCare mv            -> DontCare    $ killVar i mv  instance KillVar Type where   killVar i (El s t) = El s $ killVar i t@@ -503,6 +496,9 @@  instance KillVar a => KillVar [a] where   killVar i = map (killVar i)++instance KillVar a => KillVar (Maybe a) where+  killVar i = fmap (killVar i)  instance (KillVar a, KillVar b) => KillVar (a, b) where   killVar i (x, y) = (killVar i x, killVar i y)

src/full/Agda/TypeChecking/Tests.hs view

@@ -1,6 +1,6 @@ module Agda.TypeChecking.Tests where -import qualified Data.Set as Set+import qualified Agda.Utils.VarSet as Set import Agda.Utils.QuickCheck  import Agda.Syntax.Internal@@ -41,7 +41,7 @@ prop_reorderTelStable :: TermConfiguration -> Property prop_reorderTelStable conf =   forAll (genC conf) $ \tel ->-  reorderTel (flattenTel tel) == idP (size tel)+  reorderTel (flattenTel tel) == Just (idP (size tel))  -- | The result of splitting a telescope is well-scoped. prop_splitTelescopeScope :: TermConfiguration -> Property

src/full/Agda/TypeChecking/UniversePolymorphism.hs view

@@ -13,76 +13,17 @@ import Agda.TypeChecking.Pretty import Agda.TypeChecking.Reduce import Agda.TypeChecking.Monad.Builtin+import Agda.TypeChecking.Conversion import qualified Agda.Utils.Warshall as W  import Agda.Utils.Impossible  #include "../undefined.h" -mlevel :: MonadTCM tcm => tcm (Maybe Term)-mlevel = liftTCM $ (Just <$> primLevel) `catchError` \_ -> return Nothing--compareLevel :: MonadTCM tcm => Comparison -> Term -> Term -> tcm Constraints-compareLevel cmp u v = do-  reportSDoc "tc.conv.level" 10 $ vcat-    [ text "Comparing levels"-    , nest 2 $ sep [ prettyTCM u <+> prettyTCM cmp-                   , prettyTCM v-                   ]-    ]-  u <- reduce u-  v <- reduce v-  reportSDoc "tc.conv.level" 15 $-      nest 2 $ sep [ text (show u) <+> prettyTCM cmp-                   , text (show v)-                   ]-  let unMax (Max [a]) = a-      unMax _         = __IMPOSSIBLE__-  l1' <- unMax <$> levelView u-  l2' <- unMax <$> levelView v--  let bad = typeError $ UnequalLevel cmp u v--  let c  = min (constant l1') (constant l2')-      l1 = minus l1 c-      l2 = minus l2 c--  case (cmp, l1, l2) of-    (cmp, ClosedLevel n, ClosedLevel m) ->-      case cmp of-        CmpEq  | n == m -> return []-        CmpLeq | n <= m -> return []-        _               -> bad-    (CmpLeq, ClosedLevel 0, _) -> return []-    _ -> buildConstraint $ LevelCmp cmp u v-  where-    constant (ClosedLevel n) = n-    constant (Plus n _)      = n--    minus (ClosedLevel n) m = ClosedLevel (n - m)-    minus (Plus n l) m      = Plus (n - m) l+compareLevel :: Comparison -> Level -> Level -> TCM ()+compareLevel CmpLeq u v = leqLevel u v+compareLevel CmpEq  u v = equalLevel u v  isLevelConstraint LevelCmp{} = True isLevelConstraint _          = False -warshallConstraint :: Constraint -> TCM [W.Constraint]-warshallConstraint (LevelCmp cmp a b) = do-  -- produce constraints-  return []-warshallConstraint _ = __IMPOSSIBLE__--solveLevelConstraints :: TCM ()-solveLevelConstraints = do-  cs <- takeConstraints-  let (lcs, rest) = partition (isLevelConstraint . clValue) cs--  lcs <- concat <$> mapM warshallConstraint (map clValue lcs)--  let msol = W.solve lcs--  case msol of-    Nothing  -> typeError $ GenericError "Bad universe levels! No further information provided. You suck!"-    Just sol -> do-      -- do something interesting with the solution-      addConstraints rest-      return ()

src/full/Agda/TypeChecking/UniversePolymorphism.hs-boot view

@@ -4,5 +4,4 @@ import Agda.Syntax.Internal import Agda.TypeChecking.Monad -compareLevel :: MonadTCM tcm => Comparison -> Term -> Term -> tcm Constraints-+compareLevel :: Comparison -> Level -> Level -> TCM ()

src/full/Agda/TypeChecking/With.hs view

@@ -42,6 +42,14 @@     vs <- etaContract =<< normalise vs     as <- etaContract =<< normalise as     b  <- etaContract =<< normalise (telePi_ delta2 b)+    reportSDoc "tc.with.abstract" 40 $+      sep [ text "abstracting"+          , nest 2 $ vcat $+            [ text "vs = " <+> prettyTCM vs+            , text "as = " <+> prettyTCM as+            , text "b  = " <+> prettyTCM b ]+          ]+    reportSLn "tc.with.abstract" 50 $ "  raw vs = " ++ show vs ++ "\n  raw b  = " ++ show b     return (zip vs as, b)   return $ telePi_ delta1 $ foldr (uncurry piAbstractTerm) b vas @@ -150,7 +158,7 @@              -- Compute the argument telescope for the constructor             Con c []    <- constructorForm =<< normalise (Con c [])-            Defn _ _ ct _ _ Constructor{conPars = np}  <- getConstInfo c+            Defn {defType = ct, theDef = Constructor{conPars = np}}  <- getConstInfo c             let ct' = ct `apply` genericTake np us             TelV tel' _ <- telView ct' @@ -194,16 +202,19 @@ --   applications of the with function as applications to the original function. --   For instance, @aux a b c@ as @f (suc a) (suc b) | c@ withDisplayForm :: QName -> QName -> Telescope -> Telescope -> Nat -> [Arg Pattern] -> Permutation -> TCM DisplayForm-withDisplayForm f aux delta1 delta2 n qs perm = do+withDisplayForm f aux delta1 delta2 n qs perm@(Perm m _) = do   topArgs <- raise (n + size delta1 + size delta2) <$> getContextArgs   x <- freshNoName_   let wild = Def (qualify (mnameFromList []) x) []    let top = genericLength topArgs-      vs = topArgs ++ raiseFrom (size delta2) n (substs (sub wild) $ patsToTerms qs)-      dt = DWithApp (map DTerm $ Def f vs : withArgs) []+      vs = map (fmap DTerm) topArgs ++ (substs (sub ys wild) $ patsToTerms qs)+      dt = DWithApp (DDef f vs : map DTerm withArgs) []       withArgs = reverse $ map var [size delta2..size delta2 + n - 1]       pats = genericReplicate (n + size delta1 + size delta2 + top) (Var 0 [])+      -- Building the arguments to the with function+      (ys0, ys1) = splitAt (size delta1) (permute perm $ map Just [m - 1, m - 2..0])+      ys = reverse $ ys0 ++ genericReplicate n Nothing ++ ys1    let display = Display (n + size delta1 + size delta2 + top) pats dt @@ -214,43 +225,33 @@       , text "aux    =" <+> text (show aux)       , text "delta1 =" <+> prettyTCM delta1       , text "delta2 =" <+> prettyTCM delta2+      , text "n      =" <+> text (show n)       , text "perm   =" <+> text (show perm)+      , text "top    =" <+> prettyTCM topArgs+      , text "qs     =" <+> text (show qs)       , text "dt     =" <+> prettyTCM dt+      , text "ys     =" <+> text (show ys)       , text "raw    =" <+> text (show display)       , text "qsToTm =" <+> prettyTCM (patsToTerms qs)-      , text "sub qs =" <+> prettyTCM (substs (sub wild) $ patsToTerms qs)+      , text "sub qs =" <+> prettyTCM (substs (sub ys wild) $ patsToTerms qs)       ]     ]    return display   where     var i = Var i []-    sub wild = map term [0..] -- m - 1]+    sub rho wild = map term [0..] -- m - 1]       where-        Perm m xs = reverseP perm-        -- Perm m xs = perm    -- thinking required.. but ignored-                            -- dropping the reverse seems to work better-                            -- Andreas, 2010-09-09: I DISAGREE.-        term i = case findIndex (i ==) xs of+        -- thinking required.. but ignored+        -- dropping the reverse seems to work better+        -- Andreas, 2010-09-09: I DISAGREE.+        -- Ulf, 2011-09-02: Thinking done. Neither was correct.+        -- We had the wrong permutation and we used it incorrectly. Should work now.+        term i = case findIndex (Just i ==) rho of           Nothing -> wild           Just j  -> Var (fromIntegral j) [] -{- example (test/fail/Issue295.agda)--  aux  = aux d w a b c-  delta1 = d-  delta2 = a b c-  perm = x0,x1,x2,x3 -> x3,x0,x1,x2-  perm = a,b,c,d -> d,a,b,c-WIHOUT reverseP IS:-  dt   = (@0 ⟶ @4) ﹔ (@2 ⟶ @1) | @3-  dt   = (c ⟶ d) ﹔ (a ⟶ b) | w-WITH reverseP IS, AS IT SHOULD:-  dt   = (a ⟶ b) ﹔ (c ⟶ d) | w-  dt   = (@2 ⟶ @1) ﹔ (@0 ⟶ @4) | @3--}--patsToTerms :: [Arg Pattern] -> [Arg Term]+patsToTerms :: [Arg Pattern] -> [Arg DisplayTerm] patsToTerms ps = evalState (toTerms ps) 0   where     mapMr f xs = reverse <$> mapM f (reverse xs)@@ -261,31 +262,15 @@       put (i + 1)       return i -    toTerms :: [Arg Pattern] -> State Nat [Arg Term]+    toTerms :: [Arg Pattern] -> State Nat [Arg DisplayTerm]     toTerms ps = mapMr toArg ps -    toArg :: Arg Pattern -> State Nat (Arg Term)+    toArg :: Arg Pattern -> State Nat (Arg DisplayTerm)     toArg = T.mapM toTerm -    toTerm :: Pattern -> State Nat Term+    toTerm :: Pattern -> State Nat DisplayTerm     toTerm p = case p of-      VarP _      -> var >>= \i -> return $ Var i []-      DotP t      -> return t-      ConP c _ ps -> Con c <$> toTerms ps-      LitP l      -> return $ Lit l--data ConPos = Here-            | ArgPat Int ConPos--updateWithConstructorRanges ::-  [Telescope] -> [Arg Pattern] -> A.RHS -> [Arg Pattern]-updateWithConstructorRanges tel ps A.RHS{}            = ps-updateWithConstructorRanges tel ps A.AbsurdRHS{}      = ps-updateWithConstructorRanges tel ps (A.WithRHS _ _ cs) = ps-updateWithConstructorRanges tel ps A.RewriteRHS{}     = ps--constructorsInClauses :: ConPos -> [A.Clause] -> [Range]-constructorsInClauses pos cs = concatMap (constructorsInClause pos) cs--constructorsInClause :: ConPos -> A.Clause -> [Range]-constructorsInClause pos (A.Clause (A.LHS _ _ ps wps) rhs _) = []+      VarP _      -> var >>= \i -> return $ DTerm (Var i [])+      DotP t      -> return $ DDot t+      ConP c _ ps -> DCon c <$> toTerms ps+      LitP l      -> return $ DTerm (Lit l)

src/full/Agda/Utils/FileName.hs view

@@ -100,7 +100,7 @@ instance Arbitrary AbsolutePath where   arbitrary = mk . take 3 . map (take 2) <$>                 listOf (listOf1 (elements "a1"))-    where mk ps = AbsolutePath (joinPath $ rootPath : ps)+    where mk ps = mkAbsolute (joinPath $ rootPath : ps)  ------------------------------------------------------------------------ -- All tests

src/full/Agda/Utils/Generics.hs view

@@ -1,9 +1,20 @@ {-# LANGUAGE Rank2Types #-}-{-| Contains some generic utility functions.+{-| Contains some generic utility functions and reexports certain+    definitions from "Data.Generics". -}-module Agda.Utils.Generics where+module Agda.Utils.Generics+  ( module Data.Generics+  , isString+  , everythingBut+  , everywhereBut'+  , everywhereButM'+  ) where +-- The explicit import list is included in order to support several+-- versions of syb; one version of syb contains a definition named+-- everythingBut. import Data.Generics+  (GenericQ, mkQ, extQ, gmapQ, GenericT, gmapT, GenericM, gmapM)  isString :: GenericQ Bool isString = mkQ False (const True :: String -> Bool)

src/full/Agda/Utils/Graph.hs view

@@ -1,4 +1,4 @@-+{-# LANGUAGE DeriveFunctor #-} module Agda.Utils.Graph where  import qualified Data.Map as Map@@ -10,6 +10,7 @@  -- Only one edge between any two nodes. newtype Graph n e = Graph { unGraph :: Map n (Map n e) }+  deriving (Eq, Functor)  edges :: Ord n => Graph n e -> [(n, n, e)] edges g = concatMap onNode $ Map.assocs $ unGraph g@@ -53,9 +54,14 @@         Just es -> Graph $ Map.singleton a $ Map.map (otimes w) es         Nothing -> empty -transitiveClosure :: (SemiRing e, Ord n) => Graph n e -> Graph n e-transitiveClosure g = iterate growGraph g !! n-  where n = Set.size $ nodes g+transitiveClosure :: (Eq e, SemiRing e, Ord n) => Graph n e -> Graph n e+transitiveClosure g = loop g+  where -- n = Set.size $ nodes g+    loop g | g == g'   = g+           | otherwise = loop g'+      where+        g' = growGraph g+  findPath :: (SemiRing e, Ord n) => (e -> Bool) -> n -> n -> Graph n e -> Maybe e findPath good a b g = case filter good $ allPaths good a b g of

src/full/Agda/Utils/IO/UTF8.hs view

@@ -4,6 +4,7 @@  module Agda.Utils.IO.UTF8   ( readTextFile+  , Agda.Utils.IO.UTF8.hPutStr   , Agda.Utils.IO.UTF8.writeFile   ) where @@ -30,14 +31,26 @@   UTF8.readFile file #endif +-- | Writes UTF8-encoded text to the handle, which should be opened+-- for writing and in text mode. The native convention for line+-- endings is used.++hPutStr :: IO.Handle -> String -> IO ()+#if MIN_VERSION_base(4,2,0)+hPutStr h s = do+  IO.hSetEncoding h IO.utf8+  IO.hPutStr h s+#else+hPutStr = UTF8.hPutStr+#endif+ -- | Writes a UTF8-encoded text file. The native convention for line -- endings is used.  writeFile :: FilePath -> String -> IO () #if MIN_VERSION_base(4,2,0) writeFile file s = IO.withFile file IO.WriteMode $ \h -> do-  IO.hSetEncoding h IO.utf8-  IO.hPutStr h s+  hPutStr h s #else writeFile = UTF8.writeFile #endif

src/full/Agda/Utils/List.hs view

@@ -1,3 +1,4 @@+{-# LANGUAGE CPP #-}  {-| Utitlity functions on lists. -}@@ -13,10 +14,22 @@ import Data.Maybe import qualified Data.Set as Set +#include "../undefined.h"+import Agda.Utils.Impossible++-- | Head function (safe). mhead :: [a] -> Maybe a mhead []    = Nothing mhead (x:_) = Just x +-- | Sublist relation.+isSublistOf :: Eq a => [a] -> [a] -> Bool+isSublistOf []       ys = True+isSublistOf (x : xs) ys =+  case dropWhile (x /=) ys of+    []     -> False+    (_:ys) -> isSublistOf xs ys+ type Prefix a = [a] type Suffix a = [a] @@ -142,6 +155,32 @@   classify (x `elem` xs) "members" $     genericElemIndex x xs == elemIndex x xs +-- | Requires both lists to have the same length.++zipWith' :: (a -> b -> c) -> [a] -> [b] -> [c]+zipWith' f []        []      = []+zipWith' f (x : xs) (y : ys) = f x y : zipWith' f xs ys+zipWith' f []       (_ : _)  = {- ' -} __IMPOSSIBLE__+zipWith' f (_ : _)  []       = {- ' -} __IMPOSSIBLE__++prop_zipWith' :: (Integer -> Integer -> Integer) -> Property+prop_zipWith' f =+  forAll natural $ \n ->+    forAll (two $ vector n) $ \(xs, ys) ->+      zipWith' f xs ys == zipWith f xs ys++-- | Efficient version of nub that sorts the list first. The tag function is+--   assumed to be cheap. If it isn't pair up the elements with their tags and+--   call uniqBy fst (or snd).+uniqBy :: Ord b => (a -> b) -> [a] -> [a]+uniqBy tag =+  map head+  . groupBy ((==) `on` tag)+  . sortBy (compare `on` tag)++prop_uniqBy :: [Integer] -> Bool+prop_uniqBy xs = sort (nub xs) == uniqBy id xs+ ------------------------------------------------------------------------ -- All tests @@ -151,4 +190,6 @@   , quickCheck' prop_groupBy'   , quickCheck' prop_extractNthElement   , quickCheck' prop_genericElemIndex+  , quickCheck' prop_zipWith'+  , quickCheck' prop_uniqBy   ]

src/full/Agda/Utils/Monad.hs view

@@ -1,4 +1,4 @@-{-# LANGUAGE FlexibleContexts, CPP #-}+{-# LANGUAGE FlexibleContexts #-}  module Agda.Utils.Monad     ( module Agda.Utils.Monad@@ -14,12 +14,11 @@ import qualified Control.Monad.State.Strict as SS import Control.Monad.Writer import Control.Applicative-import Data.Traversable+import Data.Traversable hiding (sequence) import Data.Foldable import Data.Monoid -#include "../undefined.h"-import Agda.Utils.Impossible+import Agda.Utils.List  -- Monads ----------------------------------------------------------------- @@ -69,10 +68,7 @@  -- | Requires both lists to have the same lengths. zipWithM' :: Monad m => (a -> b -> m c) -> [a] -> [b] -> m [c]-zipWithM' f []	     []	      = return []-zipWithM' f (x : xs) (y : ys) = liftM2 (:) (f x y) (zipWithM' f xs ys)-zipWithM' f []	     (_ : _)  = {- ' -} __IMPOSSIBLE__-zipWithM' f (_ : _)  []	      = {- ' -} __IMPOSSIBLE__+zipWithM' f xs ys = sequence (zipWith' f xs ys)  -- | Finally for the 'Error' class. Errors in the finally part take -- precedence over prior errors.

src/full/Agda/Utils/ReadP.hs view

@@ -6,7 +6,7 @@ -- The changes are:  --  1) ReadP is parameterised over the token type (hard-wired to 'Char' in the library).---  2) Added a 'parse' function to run a parser.+--  2) Added the functions 'parse' and 'parse'' which run parsers. --  3) Removed Read instances.  -- Module      :  "Text.ParserCombinators.ReadP"@@ -39,6 +39,7 @@    -- * Parse   parse,      -- :: ReadP tok a -> [tok] -> [a]+  parse',     -- :: ReadP tok a -> [tok] -> Either a [tok]    -- * Other operations   pfail,      -- :: ReadP a@@ -394,6 +395,20 @@ --   parser, and therefore a possible inefficiency. readS_to_P r =   R (\k -> Look (\s -> final [bs'' | (a,s') <- r s, bs'' <- run (k a) s']))++-- ---------------------------------------------------------------------------+-- A variant on parse which returns either a result, or the unparseable text.++run' :: P t a -> [t] -> Either a [t]+run' (Get f)           (c:s) = run' (f c) s+run' (Look f)          s     = run' (f s) s+run' (Result x _)      _     = Left x+run' (Final ((x,_):_)) _     = Left x+run' _                 s     = Right s++parse' :: ReadP t a -> [t] -> Either a [t]+parse' p ts = case complete p of+    R f	-> run' (f return) ts  -- --------------------------------------------------------------------------- -- QuickCheck properties that hold for the combinators

src/full/Agda/Utils/Size.hs view

@@ -18,3 +18,7 @@  instance Sized (Set a) where   size = fromIntegral . Set.size++instance Sized a => Sized (Maybe a) where+  size Nothing  = 1+  size (Just a) = size a

src/full/Agda/Utils/String.hs view

@@ -33,7 +33,7 @@ -- | Shows a non-negative integer using the characters ₀-₉ instead of -- 0-9. -showIndex :: Integral i => i -> String+showIndex :: (Show i, Integral i) => i -> String showIndex n =   showIntAtBase 10 (\i -> toEnum (i + fromEnum '\x2080')) n ""

+ src/full/Agda/Utils/VarSet.hs view

@@ -0,0 +1,54 @@++-- | Var field implementation of sets of (small) natural numbers.+module Agda.Utils.VarSet+  ( VarSet+  , union, unions, member, empty, delete, singleton, fromList, toList, isSubsetOf+  , Agda.Utils.VarSet.subtract+  )+  where++import Data.Set as Set++type VarSet = Set Integer++subtract :: Integer -> VarSet -> VarSet+subtract n s = Set.mapMonotonic (Prelude.subtract n) s++{-+import Data.Bits++type VarSet = Integer+type Var    = Integer++union :: VarSet -> VarSet -> VarSet+union = (.|.)++member :: Var -> VarSet -> Bool+member b s = testVar s (fromIntegral b)++empty :: VarSet+empty = 0++delete :: Var -> VarSet -> VarSet+delete b s = clearVar s (fromIntegral b)++singleton :: Var -> VarSet+singleton = bit++subtract :: Int -> VarSet -> VarSet+subtract n s = shiftR s n++fromList :: [Var] -> VarSet+fromList = foldr (union . singleton . fromIntegral) empty++isSubsetOf :: VarSet -> VarSet -> Bool+isSubsetOf s1 s2 = 0 == (s1 .&. complement s2)++toList :: VarSet -> [Var]+toList s = loop 0 s+  where+    loop i 0 = []+    loop i n+      | testVar n 0 = fromIntegral i : (loop $! i + 1) (shiftR n 1)+      | otherwise   = (loop $! i + 1) (shiftR n 1)+-}