packages feed

haskell-src-exts 1.13.5 → 1.14.0

raw patch · 105 files changed

+14323/−14903 lines, 105 filesdep +directorydep +filepathdep +haskell-src-extsdep ~basesetup-changedPVP ok

version bump matches the API change (PVP)

Dependencies added: directory, filepath, haskell-src-exts, smallcheck, tasty, tasty-hunit, tasty-smallcheck

Dependency ranges changed: base

API changes (from Hackage documentation)

- Language.Haskell.Exts.Extension: NoImplicitPrelude :: Extension
- Language.Haskell.Exts.Extension: NoMonoPatBinds :: Extension
- Language.Haskell.Exts.Extension: NoMonomorphismRestriction :: Extension
- Language.Haskell.Exts.Extension: haskell2010 :: [Extension]
- Language.Haskell.Exts.Extension: haskell98 :: [Extension]
+ Language.Haskell.Exts.Annotated.Syntax: CApi :: l -> CallConv l
+ Language.Haskell.Exts.Annotated.Syntax: PlayInterruptible :: l -> Safety l
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable Activation
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable Alt
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable Annotation
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable Assoc
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable Asst
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable BangType
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable Binds
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable Bracket
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable CName
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable CallConv
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable ClassDecl
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable ConDecl
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable Context
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable DataOrNew
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable Decl
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable DeclHead
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable Deriving
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable Exp
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable ExportSpec
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable ExportSpecList
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable FieldDecl
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable FieldUpdate
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable FunDep
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable GadtDecl
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable GuardedAlt
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable GuardedAlts
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable GuardedRhs
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable IPBind
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable IPName
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable ImportDecl
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable ImportSpec
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable ImportSpecList
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable InstDecl
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable InstHead
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable Kind
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable Literal
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable Match
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable Module
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable ModuleHead
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable ModuleName
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable ModulePragma
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable Name
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable Op
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable PXAttr
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable Pat
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable PatField
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable QName
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable QOp
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable QualConDecl
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable QualStmt
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable RPat
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable RPatOp
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable Rhs
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable Rule
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable RuleVar
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable Safety
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable SpecialCon
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable Splice
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable Stmt
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable TyVarBind
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable Type
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable WarningText
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable XAttr
+ Language.Haskell.Exts.Annotated.Syntax: instance Foldable XName
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable Activation
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable Alt
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable Annotation
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable Assoc
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable Asst
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable BangType
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable Binds
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable Bracket
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable CName
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable CallConv
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable ClassDecl
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable ConDecl
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable Context
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable DataOrNew
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable Decl
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable DeclHead
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable Deriving
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable Exp
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable ExportSpec
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable ExportSpecList
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable FieldDecl
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable FieldUpdate
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable FunDep
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable GadtDecl
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable GuardedAlt
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable GuardedAlts
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable GuardedRhs
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable IPBind
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable IPName
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable ImportDecl
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable ImportSpec
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable ImportSpecList
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable InstDecl
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable InstHead
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable Kind
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable Literal
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable Match
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable Module
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable ModuleHead
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable ModuleName
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable ModulePragma
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable Name
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable Op
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable PXAttr
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable Pat
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable PatField
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable QName
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable QOp
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable QualConDecl
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable QualStmt
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable RPat
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable RPatOp
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable Rhs
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable Rule
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable RuleVar
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable Safety
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable SpecialCon
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable Splice
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable Stmt
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable TyVarBind
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable Type
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable WarningText
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable XAttr
+ Language.Haskell.Exts.Annotated.Syntax: instance Traversable XName
+ Language.Haskell.Exts.Extension: CApiFFI :: KnownExtension
+ Language.Haskell.Exts.Extension: DatatypeContexts :: KnownExtension
+ Language.Haskell.Exts.Extension: DeriveFoldable :: KnownExtension
+ Language.Haskell.Exts.Extension: DeriveFunctor :: KnownExtension
+ Language.Haskell.Exts.Extension: DeriveTraversable :: KnownExtension
+ Language.Haskell.Exts.Extension: DisableExtension :: KnownExtension -> Extension
+ Language.Haskell.Exts.Extension: EnableExtension :: KnownExtension -> Extension
+ Language.Haskell.Exts.Extension: GHCForeignImportPrim :: KnownExtension
+ Language.Haskell.Exts.Extension: Haskell2010 :: Language
+ Language.Haskell.Exts.Extension: Haskell98 :: Language
+ Language.Haskell.Exts.Extension: HaskellAllDisabled :: Language
+ Language.Haskell.Exts.Extension: ImplicitPrelude :: KnownExtension
+ Language.Haskell.Exts.Extension: InterruptibleFFI :: KnownExtension
+ Language.Haskell.Exts.Extension: MonoLocalBinds :: KnownExtension
+ Language.Haskell.Exts.Extension: MonomorphismRestriction :: KnownExtension
+ Language.Haskell.Exts.Extension: NondecreasingIndentation :: KnownExtension
+ Language.Haskell.Exts.Extension: RebindableSyntax :: KnownExtension
+ Language.Haskell.Exts.Extension: UnknownLanguage :: String -> Language
+ Language.Haskell.Exts.Extension: classifyLanguage :: String -> Language
+ Language.Haskell.Exts.Extension: data KnownExtension
+ Language.Haskell.Exts.Extension: data Language
+ Language.Haskell.Exts.Extension: deprecatedExtensions :: [(Extension, Maybe Extension)]
+ Language.Haskell.Exts.Extension: ghcDefault :: [Extension]
+ Language.Haskell.Exts.Extension: instance Bounded KnownExtension
+ Language.Haskell.Exts.Extension: instance Enum KnownExtension
+ Language.Haskell.Exts.Extension: instance Eq KnownExtension
+ Language.Haskell.Exts.Extension: instance Eq Language
+ Language.Haskell.Exts.Extension: instance Ord KnownExtension
+ Language.Haskell.Exts.Extension: instance Ord Language
+ Language.Haskell.Exts.Extension: instance Read KnownExtension
+ Language.Haskell.Exts.Extension: instance Read Language
+ Language.Haskell.Exts.Extension: instance Show KnownExtension
+ Language.Haskell.Exts.Extension: instance Show Language
+ Language.Haskell.Exts.Extension: knownLanguages :: [Language]
+ Language.Haskell.Exts.Extension: parseExtension :: String -> Extension
+ Language.Haskell.Exts.Extension: prettyExtension :: Extension -> String
+ Language.Haskell.Exts.Extension: prettyLanguage :: Language -> String
+ Language.Haskell.Exts.Extension: toExtensionList :: Language -> [Extension] -> [KnownExtension]
+ Language.Haskell.Exts.Lexer: KW_CApi :: Token
+ Language.Haskell.Exts.Lexer: KW_Interruptible :: Token
+ Language.Haskell.Exts.Parser: baseLanguage :: ParseMode -> Language
+ Language.Haskell.Exts.Syntax: CApi :: CallConv
+ Language.Haskell.Exts.Syntax: PlayInterruptible :: Safety
- Language.Haskell.Exts: readExtensions :: String -> Maybe [Extension]
+ Language.Haskell.Exts: readExtensions :: String -> Maybe (Maybe Language, [Extension])
- Language.Haskell.Exts.Annotated: readExtensions :: String -> Maybe [Extension]
+ Language.Haskell.Exts.Annotated: readExtensions :: String -> Maybe (Maybe Language, [Extension])
- Language.Haskell.Exts.Annotated.Syntax: PTuple :: l -> [Pat l] -> Pat l
+ Language.Haskell.Exts.Annotated.Syntax: PTuple :: l -> Boxed -> [Pat l] -> Pat l
- Language.Haskell.Exts.Annotated.Syntax: SpecSig :: l -> (QName l) -> [Type l] -> Decl l
+ Language.Haskell.Exts.Annotated.Syntax: SpecSig :: l -> (Maybe (Activation l)) -> (QName l) -> [Type l] -> Decl l
- Language.Haskell.Exts.Annotated.Syntax: Tuple :: l -> [Exp l] -> Exp l
+ Language.Haskell.Exts.Annotated.Syntax: Tuple :: l -> Boxed -> [Exp l] -> Exp l
- Language.Haskell.Exts.Annotated.Syntax: TupleSection :: l -> [Maybe (Exp l)] -> Exp l
+ Language.Haskell.Exts.Annotated.Syntax: TupleSection :: l -> Boxed -> [Maybe (Exp l)] -> Exp l
- Language.Haskell.Exts.Extension: Arrows :: Extension
+ Language.Haskell.Exts.Extension: Arrows :: KnownExtension
- Language.Haskell.Exts.Extension: BangPatterns :: Extension
+ Language.Haskell.Exts.Extension: BangPatterns :: KnownExtension
- Language.Haskell.Exts.Extension: CPP :: Extension
+ Language.Haskell.Exts.Extension: CPP :: KnownExtension
- Language.Haskell.Exts.Extension: ConstrainedClassMethods :: Extension
+ Language.Haskell.Exts.Extension: ConstrainedClassMethods :: KnownExtension
- Language.Haskell.Exts.Extension: DeriveDataTypeable :: Extension
+ Language.Haskell.Exts.Extension: DeriveDataTypeable :: KnownExtension
- Language.Haskell.Exts.Extension: DisambiguateRecordFields :: Extension
+ Language.Haskell.Exts.Extension: DisambiguateRecordFields :: KnownExtension
- Language.Haskell.Exts.Extension: DoAndIfThenElse :: Extension
+ Language.Haskell.Exts.Extension: DoAndIfThenElse :: KnownExtension
- Language.Haskell.Exts.Extension: EmptyDataDecls :: Extension
+ Language.Haskell.Exts.Extension: EmptyDataDecls :: KnownExtension
- Language.Haskell.Exts.Extension: ExistentialQuantification :: Extension
+ Language.Haskell.Exts.Extension: ExistentialQuantification :: KnownExtension
- Language.Haskell.Exts.Extension: ExplicitForAll :: Extension
+ Language.Haskell.Exts.Extension: ExplicitForAll :: KnownExtension
- Language.Haskell.Exts.Extension: ExtendedDefaultRules :: Extension
+ Language.Haskell.Exts.Extension: ExtendedDefaultRules :: KnownExtension
- Language.Haskell.Exts.Extension: ExtensibleRecords :: Extension
+ Language.Haskell.Exts.Extension: ExtensibleRecords :: KnownExtension
- Language.Haskell.Exts.Extension: FlexibleContexts :: Extension
+ Language.Haskell.Exts.Extension: FlexibleContexts :: KnownExtension
- Language.Haskell.Exts.Extension: FlexibleInstances :: Extension
+ Language.Haskell.Exts.Extension: FlexibleInstances :: KnownExtension
- Language.Haskell.Exts.Extension: ForeignFunctionInterface :: Extension
+ Language.Haskell.Exts.Extension: ForeignFunctionInterface :: KnownExtension
- Language.Haskell.Exts.Extension: FunctionalDependencies :: Extension
+ Language.Haskell.Exts.Extension: FunctionalDependencies :: KnownExtension
- Language.Haskell.Exts.Extension: GADTs :: Extension
+ Language.Haskell.Exts.Extension: GADTs :: KnownExtension
- Language.Haskell.Exts.Extension: GeneralizedNewtypeDeriving :: Extension
+ Language.Haskell.Exts.Extension: GeneralizedNewtypeDeriving :: KnownExtension
- Language.Haskell.Exts.Extension: Generics :: Extension
+ Language.Haskell.Exts.Extension: Generics :: KnownExtension
- Language.Haskell.Exts.Extension: HereDocuments :: Extension
+ Language.Haskell.Exts.Extension: HereDocuments :: KnownExtension
- Language.Haskell.Exts.Extension: ImplicitParams :: Extension
+ Language.Haskell.Exts.Extension: ImplicitParams :: KnownExtension
- Language.Haskell.Exts.Extension: ImpredicativeTypes :: Extension
+ Language.Haskell.Exts.Extension: ImpredicativeTypes :: KnownExtension
- Language.Haskell.Exts.Extension: IncoherentInstances :: Extension
+ Language.Haskell.Exts.Extension: IncoherentInstances :: KnownExtension
- Language.Haskell.Exts.Extension: KindSignatures :: Extension
+ Language.Haskell.Exts.Extension: KindSignatures :: KnownExtension
- Language.Haskell.Exts.Extension: LiberalTypeSynonyms :: Extension
+ Language.Haskell.Exts.Extension: LiberalTypeSynonyms :: KnownExtension
- Language.Haskell.Exts.Extension: MagicHash :: Extension
+ Language.Haskell.Exts.Extension: MagicHash :: KnownExtension
- Language.Haskell.Exts.Extension: MonoPatBinds :: Extension
+ Language.Haskell.Exts.Extension: MonoPatBinds :: KnownExtension
- Language.Haskell.Exts.Extension: MultiParamTypeClasses :: Extension
+ Language.Haskell.Exts.Extension: MultiParamTypeClasses :: KnownExtension
- Language.Haskell.Exts.Extension: NPlusKPatterns :: Extension
+ Language.Haskell.Exts.Extension: NPlusKPatterns :: KnownExtension
- Language.Haskell.Exts.Extension: NamedFieldPuns :: Extension
+ Language.Haskell.Exts.Extension: NamedFieldPuns :: KnownExtension
- Language.Haskell.Exts.Extension: NewQualifiedOperators :: Extension
+ Language.Haskell.Exts.Extension: NewQualifiedOperators :: KnownExtension
- Language.Haskell.Exts.Extension: OverlappingInstances :: Extension
+ Language.Haskell.Exts.Extension: OverlappingInstances :: KnownExtension
- Language.Haskell.Exts.Extension: OverloadedStrings :: Extension
+ Language.Haskell.Exts.Extension: OverloadedStrings :: KnownExtension
- Language.Haskell.Exts.Extension: PackageImports :: Extension
+ Language.Haskell.Exts.Extension: PackageImports :: KnownExtension
- Language.Haskell.Exts.Extension: ParallelListComp :: Extension
+ Language.Haskell.Exts.Extension: ParallelListComp :: KnownExtension
- Language.Haskell.Exts.Extension: PatternGuards :: Extension
+ Language.Haskell.Exts.Extension: PatternGuards :: KnownExtension
- Language.Haskell.Exts.Extension: PatternSignatures :: Extension
+ Language.Haskell.Exts.Extension: PatternSignatures :: KnownExtension
- Language.Haskell.Exts.Extension: PolymorphicComponents :: Extension
+ Language.Haskell.Exts.Extension: PolymorphicComponents :: KnownExtension
- Language.Haskell.Exts.Extension: PostfixOperators :: Extension
+ Language.Haskell.Exts.Extension: PostfixOperators :: KnownExtension
- Language.Haskell.Exts.Extension: QuasiQuotes :: Extension
+ Language.Haskell.Exts.Extension: QuasiQuotes :: KnownExtension
- Language.Haskell.Exts.Extension: Rank2Types :: Extension
+ Language.Haskell.Exts.Extension: Rank2Types :: KnownExtension
- Language.Haskell.Exts.Extension: RankNTypes :: Extension
+ Language.Haskell.Exts.Extension: RankNTypes :: KnownExtension
- Language.Haskell.Exts.Extension: RecordPuns :: Extension
+ Language.Haskell.Exts.Extension: RecordPuns :: KnownExtension
- Language.Haskell.Exts.Extension: RecordWildCards :: Extension
+ Language.Haskell.Exts.Extension: RecordWildCards :: KnownExtension
- Language.Haskell.Exts.Extension: RecursiveDo :: Extension
+ Language.Haskell.Exts.Extension: RecursiveDo :: KnownExtension
- Language.Haskell.Exts.Extension: RegularPatterns :: Extension
+ Language.Haskell.Exts.Extension: RegularPatterns :: KnownExtension
- Language.Haskell.Exts.Extension: RelaxedPolyRec :: Extension
+ Language.Haskell.Exts.Extension: RelaxedPolyRec :: KnownExtension
- Language.Haskell.Exts.Extension: RestrictedTypeSynonyms :: Extension
+ Language.Haskell.Exts.Extension: RestrictedTypeSynonyms :: KnownExtension
- Language.Haskell.Exts.Extension: ScopedTypeVariables :: Extension
+ Language.Haskell.Exts.Extension: ScopedTypeVariables :: KnownExtension
- Language.Haskell.Exts.Extension: StandaloneDeriving :: Extension
+ Language.Haskell.Exts.Extension: StandaloneDeriving :: KnownExtension
- Language.Haskell.Exts.Extension: TemplateHaskell :: Extension
+ Language.Haskell.Exts.Extension: TemplateHaskell :: KnownExtension
- Language.Haskell.Exts.Extension: TransformListComp :: Extension
+ Language.Haskell.Exts.Extension: TransformListComp :: KnownExtension
- Language.Haskell.Exts.Extension: TupleSections :: Extension
+ Language.Haskell.Exts.Extension: TupleSections :: KnownExtension
- Language.Haskell.Exts.Extension: TypeFamilies :: Extension
+ Language.Haskell.Exts.Extension: TypeFamilies :: KnownExtension
- Language.Haskell.Exts.Extension: TypeOperators :: Extension
+ Language.Haskell.Exts.Extension: TypeOperators :: KnownExtension
- Language.Haskell.Exts.Extension: TypeSynonymInstances :: Extension
+ Language.Haskell.Exts.Extension: TypeSynonymInstances :: KnownExtension
- Language.Haskell.Exts.Extension: UnboxedTuples :: Extension
+ Language.Haskell.Exts.Extension: UnboxedTuples :: KnownExtension
- Language.Haskell.Exts.Extension: UndecidableInstances :: Extension
+ Language.Haskell.Exts.Extension: UndecidableInstances :: KnownExtension
- Language.Haskell.Exts.Extension: UnicodeSyntax :: Extension
+ Language.Haskell.Exts.Extension: UnicodeSyntax :: KnownExtension
- Language.Haskell.Exts.Extension: UnliftedFFITypes :: Extension
+ Language.Haskell.Exts.Extension: UnliftedFFITypes :: KnownExtension
- Language.Haskell.Exts.Extension: ViewPatterns :: Extension
+ Language.Haskell.Exts.Extension: ViewPatterns :: KnownExtension
- Language.Haskell.Exts.Extension: XmlSyntax :: Extension
+ Language.Haskell.Exts.Extension: XmlSyntax :: KnownExtension
- Language.Haskell.Exts.Extension: impliesExts :: [Extension] -> [Extension]
+ Language.Haskell.Exts.Extension: impliesExts :: [KnownExtension] -> [KnownExtension]
- Language.Haskell.Exts.Parser: ParseMode :: String -> [Extension] -> Bool -> Bool -> Maybe [Fixity] -> ParseMode
+ Language.Haskell.Exts.Parser: ParseMode :: String -> Language -> [Extension] -> Bool -> Bool -> Maybe [Fixity] -> ParseMode
- Language.Haskell.Exts.Syntax: PTuple :: [Pat] -> Pat
+ Language.Haskell.Exts.Syntax: PTuple :: Boxed -> [Pat] -> Pat
- Language.Haskell.Exts.Syntax: SpecSig :: SrcLoc -> QName -> [Type] -> Decl
+ Language.Haskell.Exts.Syntax: SpecSig :: SrcLoc -> Activation -> QName -> [Type] -> Decl
- Language.Haskell.Exts.Syntax: Tuple :: [Exp] -> Exp
+ Language.Haskell.Exts.Syntax: Tuple :: Boxed -> [Exp] -> Exp
- Language.Haskell.Exts.Syntax: TupleSection :: [Maybe Exp] -> Exp
+ Language.Haskell.Exts.Syntax: TupleSection :: Boxed -> [Maybe Exp] -> Exp

Files

CHANGELOG view
@@ -1,401 +1,455 @@-** 1.13.x
-
-1.13.4 --> 1.13.5
-===============
-
-* Expose Language.Haskell.Exts.Lexer, which implements
-  a standalone token stream lexer. The module is
-  re-exported both by Language.Haskell.Exts and by 
-  Language.Haskell.Exts.Annotated.
-
-
-1.13.3 --> 1.13.4
-===============
-
-* Fix bug where operators starting with # written in
-  parentheses would not be parsed when UnboxedTuples is 
-  turned on. Now works.
-
-* Allow 'family' and 'forall' as (non-type) varid's. This 
-  adds one more shift/reduce conflict to the parser, and 
-  its resolution means that '{-# RULES "name" forall = ... #-}' 
-  is not allowed.
-
-* Complete the set of FFI calling conventions from the Haskell
-  2010 report (even if no compiler implements them). Also
-  include the 'js' calling convention, supported by UHC.
-
-
-1.13.2 --> 1.13.3
-===============
-
-* Fundep premises are now allowed to be empty.
-
-* Fix the bug where the lexer would crash on a LINE pragma
-  that did not include a line number.
-
-* Fix the bug where the lexer would require the # of a
-  MagicHash-style type constructor to be succeeded by at
-  least one character in the file.
-
-* Fix long-standing bug where the parser would crash with
-  an ugly "Internal error" error message if encountering
-  an extra }.
-
-* Report errors at the right place for function arity
-  mismatches. Earlier they were reported at end of file,
-  now they are reported where the function is declared.
-
-* Lexer now properly fails on line-breaks in string literals.
-
-* Lexer now handles character escapes up to 0x10FFFF (unicode).
-
-
-1.13.1 --> 1.13.2
-===============
-
-* Fix the bug with the precedence of unary prefix minus.
-  Previously it was resolved as binding more tightly
-  than any infix operator, now it is correctly treated
-  as having the same fixity as binary infix minus.
-
-
-1.13.0 --> 1.13.1
-===============
-
-* Allow an optional semi before the closing tag of
-  an element. This achieves a similar effect for
-  XmlSyntax in do blocks as DoAndIfThenElse does for
-  the if construct. No more need to indent the closing
-  tag one step further than the opening tag.
-
-* Add a dummy 'noLoc :: SrcLoc' to L.H.E.SrcLoc, to
-  use when generating code. It could definitely be
-  done more elegantly, but not without inducing another
-  major version bump, so later.
-
-* Fix a regression from 1.11.x where the parser would crash
-  upon encountering non-simple class/data declaration
-  heads, e.g. 'data A [a]'. Now fails with a parse error
-  as intended.
-
-
-1.12.0 --> 1.13.0
-===============
-
-* Add extensions DoAndIfThenElse and NPlusKPatterns to
-  Language.Haskell.Exts.Extensions.
-
-* DoAndIfThenElse is now supported, at long last,
-  making HSE compatible with Haskell2010
-
-* Introduce haskell98 and haskell2010 extension groups,
-  exported from Language.Haskell.Exts.Extensions.
-
-* Backwards-incompatible change: default parse mode
-  is now to use haskell2010, which means the following
-  features are recognized by default: DoAndIfThenElse,
-  PatternGuards, ForeignFunctionInterface, EmptyDataDecls.
-  NPlusKPatterns is no longer recognized by default.
-
-
-** 1.12.x
-
-1.11.1 --> 1.12.0
-===============
-
-* Move from old [$...| quasi-quote syntax to the new [...| one.
-  The old syntax is still recognized while parsing.
-
-* Allow symbols as variables when TypeOperators is enabled.
-
-* Rename ExplicitForall in ExplicitForAll, to be consistent
-  with GHC and the Haskell' process.
-
-
-** 1.11.x
-
-1.10.2 --> 1.11.1
-===============
-
-* API change: the fixities field in ParseMode is now of type
-  Maybe [Fixity].  If the field is Nothing the parsing will
-  not try to do any fixity resolution whatsoever, otherwise
-  it behaves as before.
-
-* API change, bug fix: The Fixity type contains a QName rather
-  than an Op to name the operator.  The operator must match
-  the given QName exactly (i.e., unqualified names only match
-  unqualified names, and qualified names only match qualified
-  names) for applyFixities to perform fixups.
-
-* Bug fix: End-of-file inside an OPTIONS pragma no longer loops.
-
-
-
-** 1.10.x
-
-1.10.1 --> 1.10.2
-===============
-
-* Fix a missing case in the Functor declaration for Decl. Thanks
-  to Malcolm Wallace for the patch!
-
-1.10.0 --> 1.10.1
-===============
-
-* Enable the unicode version of DoubleColon (x2237). Thanks
-  to Andrés Sicard-Ramírez for the patch!
-
-1.9.6 --> 1.10.0
-===============
-
-* Ensure that implied extensions are always picked up, not only
-  when using the parseFile* family of functions as previously.
-
-* Add the newly devised <%>...</%> syntax to the XmlSyntax support.
-  This causes changes to pretty much everything, including adding
-  a case to the AST which prompts the major version bump.
-
-
-** 1.9.x
-
-1.9.5 --> 1.9.6
-===============
-
-* Fix a bug (#203) where the lexer loops on malformed quasi-quoters.
-
-* Fix a bug with pretty-printing RULES pragmas.
-
-1.9.4 --> 1.9.5
-===============
-
-* Fix a bug where deriving clauses for GADT-style data declarations
-  were not properly indented.
-
-* Pretty-printing patterns is now more accurate in inserting (and not
-  inserting) parentheses when needed.
-
-1.9.3 --> 1.9.4
-===============
-
-* Pretty-printer now inserts parentheses in clever places when 
-  printing kinds.
-
-* Pretty-printing expressions is now far more accurate in inserting
-  (and not inserting) parentheses when needed.
-  
-* Pretty-printing negative expressions no longer inserts a superfluous
-  space between the - and the expression.
-
-1.9.2 --> 1.9.3
-===============
-
-* Constructors for newtype declarations must now have exactly one
-  argument. This is only when using the classic syntax, not with
-  GADT-style syntax.
-
-* Fix a bug where preceding commas in tuple sections were counted
-  one too few.
-
-1.9.1 --> 1.9.2
-===============
-
-* Fix a bug with pretty-printing lexer tokens.
-
-* Fix a bug where non-colon TypeOperators could not be used in
-  prefix mode.
-
-1.9.0 --> 1.9.1
-===============
-
-* Export parseFileContentsWithExts from .Exts.
-
-1.8.2 --> 1.9.0
-===============
-
-* OptionPragma is renamed to the more descriptive ModulePragma,
-  and adds a constructor AnnModulePragma for handling ANN pragmas
-  preceding module header.
-
-* Add instances for Eq/Ord/Data/Typeable for Fixity.
-
-* Add 'parseFileWithComments' and 'parseFileContentsWithComments'
-  to L.H.Exts .
-
-* More informative error messages when HSX tags are mismatched.
-
-
-
-** 1.8.x
-
-1.8.1 --> 1.8.2
-===============
-
-* Don't insert redundant parentheses around record constructions
-  and updates.
-
-1.8.0 --> 1.8.1
-===============
-
-* Fix three bugs with the handling of ANN. I must have been really
-  tired when implementing that support.
-
-1.7.2 --> 1.8.0
-===============
-
-* Add an instance Show Fixity (derived).
-
-* Support for the new ANN and INLINE_CONLIKE pragmas.
-
-* Export knownExtensions from .Extension.
-
-* Remove support for CFILES and INCLUDE pragmas. The support wasn't 
-  correct anyway, as it assumed the pragmas appeared at the top of 
-  files. As CFILES/INCLUDE pragmas can (and do) appear anywhere, 
-  there's no hope to support them in the AST. Better to remove the 
-  support altogether. Files with CFILES/INCLUDE pragmas can still 
-  be parsed of course, but those pragmas will be handled as comments.
-
-* Parsing with ignoreLinePragmas = False now correctly updates the
-  file name.
-
-* Allow the whole SPECIALISE/INLINE family of pragmas in instance
-  declarations. The InsInline constructor is removed, and is now
-  represented by InsDecl (InlineSig ...).
-
-* Fix a bug with line numbering and quasi quotes, and a similar one 
-  with line numbering and CDATA.
-
-* Fix a few minor bugs in the exactPrinter.
-
-* Fix the strange handling of so called strings in LINE pragmas.
-
-** 1.7.x
-
-1.7.1 --> 1.7.2
-===============
-
-* Fixes a bug in lexing LINE pragmas (used when ignoreLinePragmas
-  is set to False).
-
-1.7.0 --> 1.7.1
-===============
-
-* UnicodeSyntax now also enables the forall symbol (U+2200).
-
-1.6.1 --> 1.7.0
-===============
-
-* Operators defined on the form
-  
-     (a `op` b) c = ...
-  
-  could not be handled by the (annotated) AST, nor the parser. I had to 
-  change the definition of the AST node for InfixMatch to allow a list
-  of right-hand subpatterns, i.e.
-  
-     InfixMatch l (Pat l) (Name l) (Pat l) ...
-  
-  has become
-  
-     InfixMatch l (Pat l) (Name l) [Pat l] ...
-
-  I also had an epiphany and fixed the issue that would arise with
-  exact printing of prefix definitions including parentheses, so 
-  that now works too!
-
-** 1.6.x
-
-1.6.0 --> 1.6.1
-===============
-
-* UnicodeSyntax now works not only for identifiers, but also for
-  ->, <- and =>, as well as Arrows arrows and kind stars.
-
-1.5.3 --> 1.6.0
-===============
-
-* (=~=) turns out to be too general at Functor (for intuitive and not
-  technical reasons), so is specialised to Annotated to closer mirror
-  the original intention.
-
-* applyFixities is hoisted to a monad, and now fails on ambiguous infix
-  expressions.
-
-** 1.5.x
-
-1.5.2 --> 1.5.3
-===============
-
-* Several small bug fixes in the exact printer, and fail more gracefully
-  if the number of srcInfoPoints doesn't match the needs of the node.
-
-1.5.1 --> 1.5.2
-===============
-
-* Fix a bug in the exact printer that made it always print the first token
-  at position (0,0).
-
-* In fixing the above, Annotated is now a superclass of ExactP. It was already
-  a superclass in spirit, and nothing can break from this since ExactP is only
-  exported abstractly.
-
-1.5.0 --> 1.5.1
-===============
-
-* The pretty printer now introduces parentheses for non-atomic arguments to
-  function application. Note that infix applications are left untouched, no
-  parentheses will be inserted there, as it is assumed that fixities are
-  already properly resolved.
-
-* Fix a bug in the pretty printer where view patterns and n+k patterns were
-  not properly parenthesised.
-
-1.4.0 --> 1.5.0
-===============
-
-* Add support for acting on LINE pragmas while parsing, i.e. updating the source
-  position according to info given in LINE pragmas. This is done conditionally
-  based on a new flag ignoreLinePragmas in the ParseMode, hence the need to
-  increase the major version.
-
-** 1.4.x
-
-1.3.5 --> 1.4.0
-===============
-
-* The AST node for Proc in the simple AST is changed to include a SrcLoc argument,
-  to make it consistent with similar nodes e.g. Lambda. This is specifically needed
-  for transformation of patterns in HSX.
-
-
-** 1.3.x
-
-1.3.4 --> 1.3.5
-===============
-
-* Added an entry point in the parser for statements, and an instance Parseable Stmt
-  to go with it.
-
-* Ensured that .Annotated exports all relevant parseXXX(WithYYY) functions.
-
-1.3.3 --> 1.3.4
-===============
-
-* Operator fixities are now resolved in patterns.
-
-1.3.2 --> 1.3.3
-===============
-
-* Fixes a bug where qualified keywords are rejected even if the extension that
-  enables the keyword in question is not turned on.
-
-
-1.3.0 --> 1.3.2
-===============
-
-(Let's forget 1.3.1 ever existed.)
-
-* Fix a bug where declarations of infix operators were not properly merged as FunBinds.
-
+** 1.14.x++1.13.6 --> 1.14.0+===============++* Modernize the Extension datatype in L.H.E.Extension, following the lead+  of Cabal, to allow negative and positive extension modifiers (turning+  features on and off). You need to worry about backwards-incompatible +  changes if any of the following pertains to you:+  1) If you use the Extension datatype programmatically - it has changed+     significantly (see documentation).+  2) The ParseMode record now has one more field+     (baseLanguage :: Language), which might give you a type error.+  3) The behavior of the (extensions :: [Extension]) field has changed,+     which could bite you if you pass custom extensions in the ParseMode. +     Previously, the ParseMode defaulted to the list of extensions accepted +     by Haskell2010, and if you set the list explicitly you would override +     this. Now, the defaults are { baseLanguage = Haskell2010, extensions = [] },+     and explicitly setting a list of extensions will be interpreted on top of+     Haskell2010. See further the documentation for L.H.E.Extension.++* Add support for the 'capi' calling convention. It is enabled with the CApiFFI+  extension. It's been included since GHC 7.4, and advertised since 7.6.++* Add support for the 'interruptible' FFI safety annotation, enabled with+  the InterruptibleFFI extension.++* Give better error message when lexing newline fails. In particular, fix the bug+  when the parser would crash if the file didn't end with a newline.++* Support unboxed tuple expressions and patterns.++* Fix bug in lexing of primitive integer literals in hex or octal notation.++* Disallow negative primitive word literals+  (such as W# (-0x8000000000000000##)).++* Allow phase control for SPECIALIZE pragma.++* Derive Foldable and Traversable instances for all annotated AST types.++* Fix bug with pretty-printing WARNING and DEPRECATED pragmas.+++** 1.13.x++1.13.5 --> 1.13.6+===============++* Allow 0-parameter type classes when MultiParamTypeClasses is on.++* Add support for NondecreasingIndentation. Previously it was always on,+  which is the default behavior in GHC. Now it is on only if enabled, or+  when using the newly added ghcDefaults extension set (instead of haskell2010).+++1.13.4 --> 1.13.5+===============++* Expose Language.Haskell.Exts.Lexer, which implements+  a standalone token stream lexer. The module is+  re-exported both by Language.Haskell.Exts and by +  Language.Haskell.Exts.Annotated.+++1.13.3 --> 1.13.4+===============++* Fix bug where operators starting with # written in+  parentheses would not be parsed when UnboxedTuples is +  turned on. Now works.++* Allow 'family' and 'forall' as (non-type) varid's. This +  adds one more shift/reduce conflict to the parser, and +  its resolution means that '{-# RULES "name" forall = ... #-}' +  is not allowed.++* Complete the set of FFI calling conventions from the Haskell+  2010 report (even if no compiler implements them). Also+  include the 'js' calling convention, supported by UHC.+++1.13.2 --> 1.13.3+===============++* Fundep premises are now allowed to be empty.++* Fix the bug where the lexer would crash on a LINE pragma+  that did not include a line number.++* Fix the bug where the lexer would require the # of a+  MagicHash-style type constructor to be succeeded by at+  least one character in the file.++* Fix long-standing bug where the parser would crash with+  an ugly "Internal error" error message if encountering+  an extra }.++* Report errors at the right place for function arity+  mismatches. Earlier they were reported at end of file,+  now they are reported where the function is declared.++* Lexer now properly fails on line-breaks in string literals.++* Lexer now handles character escapes up to 0x10FFFF (unicode).+++1.13.1 --> 1.13.2+===============++* Fix the bug with the precedence of unary prefix minus.+  Previously it was resolved as binding more tightly+  than any infix operator, now it is correctly treated+  as having the same fixity as binary infix minus.+++1.13.0 --> 1.13.1+===============++* Allow an optional semi before the closing tag of+  an element. This achieves a similar effect for+  XmlSyntax in do blocks as DoAndIfThenElse does for+  the if construct. No more need to indent the closing+  tag one step further than the opening tag.++* Add a dummy 'noLoc :: SrcLoc' to L.H.E.SrcLoc, to+  use when generating code. It could definitely be+  done more elegantly, but not without inducing another+  major version bump, so later.++* Fix a regression from 1.11.x where the parser would crash+  upon encountering non-simple class/data declaration+  heads, e.g. 'data A [a]'. Now fails with a parse error+  as intended.+++1.12.0 --> 1.13.0+===============++* Add extensions DoAndIfThenElse and NPlusKPatterns to+  Language.Haskell.Exts.Extensions.++* DoAndIfThenElse is now supported, at long last,+  making HSE compatible with Haskell2010++* Introduce haskell98 and haskell2010 extension groups,+  exported from Language.Haskell.Exts.Extensions.++* Backwards-incompatible change: default parse mode+  is now to use haskell2010, which means the following+  features are recognized by default: DoAndIfThenElse,+  PatternGuards, ForeignFunctionInterface, EmptyDataDecls.+  NPlusKPatterns is no longer recognized by default.+++** 1.12.x++1.11.1 --> 1.12.0+===============++* Move from old [$...| quasi-quote syntax to the new [...| one.+  The old syntax is still recognized while parsing.++* Allow symbols as variables when TypeOperators is enabled.++* Rename ExplicitForall in ExplicitForAll, to be consistent+  with GHC and the Haskell' process.+++** 1.11.x++1.10.2 --> 1.11.1+===============++* API change: the fixities field in ParseMode is now of type+  Maybe [Fixity].  If the field is Nothing the parsing will+  not try to do any fixity resolution whatsoever, otherwise+  it behaves as before.++* API change, bug fix: The Fixity type contains a QName rather+  than an Op to name the operator.  The operator must match+  the given QName exactly (i.e., unqualified names only match+  unqualified names, and qualified names only match qualified+  names) for applyFixities to perform fixups.++* Bug fix: End-of-file inside an OPTIONS pragma no longer loops.++++** 1.10.x++1.10.1 --> 1.10.2+===============++* Fix a missing case in the Functor declaration for Decl. Thanks+  to Malcolm Wallace for the patch!++1.10.0 --> 1.10.1+===============++* Enable the unicode version of DoubleColon (x2237). Thanks+  to Andrés Sicard-Ramírez for the patch!++1.9.6 --> 1.10.0+===============++* Ensure that implied extensions are always picked up, not only+  when using the parseFile* family of functions as previously.++* Add the newly devised <%>...</%> syntax to the XmlSyntax support.+  This causes changes to pretty much everything, including adding+  a case to the AST which prompts the major version bump.+++** 1.9.x++1.9.5 --> 1.9.6+===============++* Fix a bug (#203) where the lexer loops on malformed quasi-quoters.++* Fix a bug with pretty-printing RULES pragmas.++1.9.4 --> 1.9.5+===============++* Fix a bug where deriving clauses for GADT-style data declarations+  were not properly indented.++* Pretty-printing patterns is now more accurate in inserting (and not+  inserting) parentheses when needed.++1.9.3 --> 1.9.4+===============++* Pretty-printer now inserts parentheses in clever places when +  printing kinds.++* Pretty-printing expressions is now far more accurate in inserting+  (and not inserting) parentheses when needed.+  +* Pretty-printing negative expressions no longer inserts a superfluous+  space between the - and the expression.++1.9.2 --> 1.9.3+===============++* Constructors for newtype declarations must now have exactly one+  argument. This is only when using the classic syntax, not with+  GADT-style syntax.++* Fix a bug where preceding commas in tuple sections were counted+  one too few.++1.9.1 --> 1.9.2+===============++* Fix a bug with pretty-printing lexer tokens.++* Fix a bug where non-colon TypeOperators could not be used in+  prefix mode.++1.9.0 --> 1.9.1+===============++* Export parseFileContentsWithExts from .Exts.++1.8.2 --> 1.9.0+===============++* OptionPragma is renamed to the more descriptive ModulePragma,+  and adds a constructor AnnModulePragma for handling ANN pragmas+  preceding module header.++* Add instances for Eq/Ord/Data/Typeable for Fixity.++* Add 'parseFileWithComments' and 'parseFileContentsWithComments'+  to L.H.Exts .++* More informative error messages when HSX tags are mismatched.++++** 1.8.x++1.8.1 --> 1.8.2+===============++* Don't insert redundant parentheses around record constructions+  and updates.++1.8.0 --> 1.8.1+===============++* Fix three bugs with the handling of ANN. I must have been really+  tired when implementing that support.++1.7.2 --> 1.8.0+===============++* Add an instance Show Fixity (derived).++* Support for the new ANN and INLINE_CONLIKE pragmas.++* Export knownExtensions from .Extension.++* Remove support for CFILES and INCLUDE pragmas. The support wasn't +  correct anyway, as it assumed the pragmas appeared at the top of +  files. As CFILES/INCLUDE pragmas can (and do) appear anywhere, +  there's no hope to support them in the AST. Better to remove the +  support altogether. Files with CFILES/INCLUDE pragmas can still +  be parsed of course, but those pragmas will be handled as comments.++* Parsing with ignoreLinePragmas = False now correctly updates the+  file name.++* Allow the whole SPECIALISE/INLINE family of pragmas in instance+  declarations. The InsInline constructor is removed, and is now+  represented by InsDecl (InlineSig ...).++* Fix a bug with line numbering and quasi quotes, and a similar one +  with line numbering and CDATA.++* Fix a few minor bugs in the exactPrinter.++* Fix the strange handling of so called strings in LINE pragmas.++** 1.7.x++1.7.1 --> 1.7.2+===============++* Fixes a bug in lexing LINE pragmas (used when ignoreLinePragmas+  is set to False).++1.7.0 --> 1.7.1+===============++* UnicodeSyntax now also enables the forall symbol (U+2200).++1.6.1 --> 1.7.0+===============++* Operators defined on the form+  +     (a `op` b) c = ...+  +  could not be handled by the (annotated) AST, nor the parser. I had to +  change the definition of the AST node for InfixMatch to allow a list+  of right-hand subpatterns, i.e.+  +     InfixMatch l (Pat l) (Name l) (Pat l) ...+  +  has become+  +     InfixMatch l (Pat l) (Name l) [Pat l] ...++  I also had an epiphany and fixed the issue that would arise with+  exact printing of prefix definitions including parentheses, so +  that now works too!++** 1.6.x++1.6.0 --> 1.6.1+===============++* UnicodeSyntax now works not only for identifiers, but also for+  ->, <- and =>, as well as Arrows arrows and kind stars.++1.5.3 --> 1.6.0+===============++* (=~=) turns out to be too general at Functor (for intuitive and not+  technical reasons), so is specialised to Annotated to closer mirror+  the original intention.++* applyFixities is hoisted to a monad, and now fails on ambiguous infix+  expressions.++** 1.5.x++1.5.2 --> 1.5.3+===============++* Several small bug fixes in the exact printer, and fail more gracefully+  if the number of srcInfoPoints doesn't match the needs of the node.++1.5.1 --> 1.5.2+===============++* Fix a bug in the exact printer that made it always print the first token+  at position (0,0).++* In fixing the above, Annotated is now a superclass of ExactP. It was already+  a superclass in spirit, and nothing can break from this since ExactP is only+  exported abstractly.++1.5.0 --> 1.5.1+===============++* The pretty printer now introduces parentheses for non-atomic arguments to+  function application. Note that infix applications are left untouched, no+  parentheses will be inserted there, as it is assumed that fixities are+  already properly resolved.++* Fix a bug in the pretty printer where view patterns and n+k patterns were+  not properly parenthesised.++1.4.0 --> 1.5.0+===============++* Add support for acting on LINE pragmas while parsing, i.e. updating the source+  position according to info given in LINE pragmas. This is done conditionally+  based on a new flag ignoreLinePragmas in the ParseMode, hence the need to+  increase the major version.++** 1.4.x++1.3.5 --> 1.4.0+===============++* The AST node for Proc in the simple AST is changed to include a SrcLoc argument,+  to make it consistent with similar nodes e.g. Lambda. This is specifically needed+  for transformation of patterns in HSX.+++** 1.3.x++1.3.4 --> 1.3.5+===============++* Added an entry point in the parser for statements, and an instance Parseable Stmt+  to go with it.++* Ensured that .Annotated exports all relevant parseXXX(WithYYY) functions.++1.3.3 --> 1.3.4+===============++* Operator fixities are now resolved in patterns.++1.3.2 --> 1.3.3+===============++* Fixes a bug where qualified keywords are rejected even if the extension that+  enables the keyword in question is not turned on.+++1.3.0 --> 1.3.2+===============++(Let's forget 1.3.1 ever existed.)++* Fix a bug where declarations of infix operators were not properly merged as FunBinds.+
Setup.hs view
@@ -1,8 +1,2 @@ import Distribution.Simple-import System.Process (rawSystem)-import System.Exit (ExitCode(..))-import System.FilePath ((</>))-main = defaultMainWithHooks $ simpleUserHooks { runTests = \args _ _ _ -> do-    ExitSuccess <- rawSystem "runhaskell" (("Test" </> "Runner.hs") : args)-    return ()-                                              }+main = defaultMain
Test/Runner.hs view
@@ -1,12 +1,19 @@ -- | Use "runhaskell Setup.hs test" or "cabal test" to run these tests.--- Particular files may be selected by supplying their names as arguments.+{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses, StandaloneDeriving #-} module Main where +import Test.Tasty+import Test.Tasty.HUnit+import Test.Tasty.SmallCheck+import Test.SmallCheck+import Test.SmallCheck.Series import Language.Haskell.Exts.Annotated import System.IO import Control.Monad+import Control.Applicative import Data.List import Data.Char+import Data.Function import System.Directory import System.Environment (getArgs) import System.Exit (exitFailure)@@ -14,24 +21,13 @@   main :: IO ()-main = go =<< getArgs----- | Run the selected tests - or all of them if the supplied list is empty-go :: [FilePath] -> IO ()-go testsToRun = do-    hSetBuffering stdout NoBuffering-    files <- if null testsToRun then getDirectoryContents examplesDir else return testsToRun-    putStrLn "Testing parser:"-    src <- liftM (map (head . words) . lines) . readFile $ "Test" </> "failing.txt"-    results <- sequence [check (x `elem` src) (examplesDir </> x) | x <- files, not $ "." `isPrefixOf` x]-    putStrLn "\nAll parsing tests completed!\n"-    putStrLn "Testing exact printer:"-    pSrc <- liftM (map (head . words) . lines) . readFile $ "Test" </> "printFail.txt"-    pResults <- sequence [roundTrip (x `elem` pSrc) (examplesDir </> x)-                            | x <- files, x `notElem` src, not $ "." `isPrefixOf` x]-    putStrLn "\nAll printing tests completed!\n"-    unless (all id $ results ++ pResults) exitFailure+main = do+    files <- getDirectoryContents examplesDir+    defaultMain . testGroup "Tests" =<<+        sequence+            [ parserTests files+            , printerTests files+            , return extProperties ]   -- | Where all the tests are to be found@@ -39,19 +35,41 @@ examplesDir = "Test" </> "examples"  --- | Runs the test, and returns True unless there is an unexpected result-check :: Bool -> FilePath -> IO Bool-check expected file = do+getParserFailing, getPrinterFailing :: IO [FilePath]+(getParserFailing, getPrinterFailing) = (get "failing.txt", get "printFail.txt")+    where+    get fname = liftM (map (head . words) . lines) . readFile $ "Test" </> fname+++parserTests :: [FilePath] -> IO TestTree+parserTests files = testGroup "Parser tests" <$> do+    failing <- getParserFailing+    return [check (x `elem` failing) (examplesDir </> x) | x <- files, not $ "." `isPrefixOf` x]+++check :: Bool -> FilePath -> TestTree+check expected file = testCase file $ do     res <- parseFile file     case res of-        ParseOk x | expected -> putStrLn ("\n<unexpected pass for " ++ file ++ ">") >> return False-                  | otherwise -> putChar '.' >> return True-        err | expected -> putChar '!' >> return True-            | otherwise -> putStrLn ("\nFailure when parsing " ++ show file ++ "\n" ++ show err) >> return False+        ParseOk x | expected -> assertFailure $ "Unexpected pass for " ++ file+                  | otherwise -> return ()+        err | expected -> return ()+            | otherwise -> assertFailure $ "Failure when parsing " ++ show file ++ "\n" ++ show err  -roundTrip :: Bool -> FilePath -> IO Bool-roundTrip expected file = do+printerTests :: [FilePath] -> IO TestTree+printerTests files = testGroup "Exact printer tests" <$> do+    parserFailing <- getParserFailing+    printerFailing <- getPrinterFailing+    return+        [ roundTrip (x `elem` printerFailing) (examplesDir </> x)+        | x <- files+        , not $ "." `isPrefixOf` x+        , not $ x `elem` parserFailing ]+++roundTrip :: Bool -> FilePath -> TestTree+roundTrip expected file = testCase file $ do     fc <- readFile file     pr <- parseFileWithComments (defaultParseMode { parseFilename = file }) file     case pr of@@ -61,14 +79,38 @@                         $ zip (map (reverse . dropWhile isSpace . reverse) $ lines fc)                               (map (reverse . dropWhile isSpace . reverse) $ lines res)       case xs of-       [] | expected  -> putStrLn ("\n<unexpected pass for " ++ file ++ ">") >> return False-          | otherwise -> putChar '.' >> return True+       [] | expected  -> assertFailure $ "Unexpected pass for " ++ file+          | otherwise -> return ()        (lfc, lres):_-          | expected  -> putChar '!' >> return True-          | otherwise -> do-              putStrLn $ "Result of print does not match input when printing " ++ show file-              putStrLn $ "First unmatching lines are (line length):"-              putStrLn $ "  Input  (" ++ show (length lfc)  ++ "): " ++ lfc-              putStrLn $ "  Result (" ++ show (length lres) ++ "): " ++ lres-              return False-     err -> putStrLn ("\nFailure when parsing " ++ show file ++ "\n" ++ show err) >> return False+          | expected  -> return ()+          | otherwise -> assertFailure $ unlines+              [ "Result of print does not match input when printing " ++ show file+              , "First unmatching lines are (line length):"+              , "  Input  (" ++ show (length lfc)  ++ "): " ++ lfc+              , "  Result (" ++ show (length lres) ++ "): " ++ lres+              ]+     err -> assertFailure $ "Failure when parsing " ++ show file ++ "\n" ++ show err++instance Monad m => Serial m Language where+  series = generate (const knownLanguages)++instance Monad m => Serial m Extension where+  series = generate (const knownExtensions)++instance Monad m => Serial m KnownExtension where+  series = generate $ const [ e | EnableExtension e <- knownExtensions ]++infix 3 ~~+(~~) :: Monad m => [Extension] -> [Extension] -> Property m+xts1 ~~ xts2 = forAll $ \lang -> ((==) `on` sort . toExtensionList lang) xts1 xts2++extProperties =+  localOption (SmallCheckDepth 2) $ testGroup "Properties of LANGUAGE extensions" $+  [ testProperty "identity" $ \x -> x ~~ x+  , testProperty "idempotence" $ \x -> x ++ x ~~ x+  , testProperty "right bias" $ \x y -> x ++ y ++ x ~~ y ++ x+  , testProperty "closedness of implication" $ \x -> impliesExts (impliesExts x) == impliesExts x+  , testProperty "closedness of toExtensionList" $ \l x -> let es = toExtensionList l x in es == impliesExts es+  , testProperty "opposite extensions 1" $ \x -> [EnableExtension x, DisableExtension x] ~~ [DisableExtension x]+  , testProperty "opposite extensions 2" $ \x -> [DisableExtension x, EnableExtension x] ~~ [EnableExtension x]+  ]
+ Test/examples/ArityMismatch.hs view
@@ -0,0 +1,7 @@+module ArityMismatch where++foo a b = 1+foo a = 2++bar = 1+baz = 2
Test/examples/ArrowLayout.hs view
@@ -1,7 +1,7 @@-{-# LANGUAGE Arrows #-}
-module ArrowLayout where
-
-exp = proc () -> do
-  rec let e = 1 + i
-      i <- integral -< e
-  returnA -< e
+{-# LANGUAGE Arrows #-}+module ArrowLayout where++exp = proc () -> do+  rec let e = 1 + i+      i <- integral -< e+  returnA -< e
+ Test/examples/BadStringLineBreak.hs view
@@ -0,0 +1,5 @@+module BadStringLineBreak where++main = print $ "hello" ++ "world+-- any random junk that goes here gets added onto the character count+-- and the quote ends it with some garbage "
Test/examples/BangPatterns.hs view
@@ -1,8 +1,8 @@-{-# LANGUAGE BangPatterns #-}
-module BangPatterns where
-
-firstnonspace :: Ptr Word8 -> Int -> Int -> IO Int
-firstnonspace !ptr !n !m
-    | n >= m    = return n
-    | otherwise = do w <- peekElemOff ptr n
-                     if isSpaceWord8 w then firstnonspace ptr (n+1) m else return n
+{-# LANGUAGE BangPatterns #-}+module BangPatterns where++firstnonspace :: Ptr Word8 -> Int -> Int -> IO Int+firstnonspace !ptr !n !m+    | n >= m    = return n+    | otherwise = do w <- peekElemOff ptr n+                     if isSpaceWord8 w then firstnonspace ptr (n+1) m else return n
Test/examples/Bug.hs view
@@ -1,2 +1,2 @@-import Test.QuickCheck
--- prop_susShortest = 2 > 1 ==> 1 /= 2
+import Test.QuickCheck+-- prop_susShortest = 2 > 1 ==> 1 /= 2
+ Test/examples/CStyleLinePragmas.hs view
@@ -0,0 +1,2 @@+#line 1 "Main.hs"+#line 2 "Main.hs"
Test/examples/ClassInstType.hs view
@@ -1,17 +1,17 @@-module ClassInstType where
-
-class Dir d where
-  localDir :: d -> IO FilePath
-
-instance Dir Directory where
-  localDir (Local f) = return f
-
-  localDir (Darcs {url=url,darcsVersion=Patch patch,subDirectory=subDir}) = do 
-    tmp <- createTempDir 0 "haskelld"
-    darcsOut <- runDarcsCommand tmp "get" ["--lazy","--to-match","hash "++ patch,url,"fs"]
-    print darcsOut
-    let (ExitSuccess,"",out) = darcsOut 
-    print out
-    return $ tmp </> "fs" </> subDir
-
-type URL = String
+module ClassInstType where++class Dir d where+  localDir :: d -> IO FilePath++instance Dir Directory where+  localDir (Local f) = return f++  localDir (Darcs {url=url,darcsVersion=Patch patch,subDirectory=subDir}) = do +    tmp <- createTempDir 0 "haskelld"+    darcsOut <- runDarcsCommand tmp "get" ["--lazy","--to-match","hash "++ patch,url,"fs"]+    print darcsOut+    let (ExitSuccess,"",out) = darcsOut +    print out+    return $ tmp </> "fs" </> subDir++type URL = String
+ Test/examples/ConstraintKinds.hs view
@@ -0,0 +1,8 @@+{-# LANGUAGE ConstraintKinds #-}+class Foo a where ++type Bar a+type Bazable a b = (Bar a ~ Maybe b)++baz :: Bazable a b => a -> a+baz = id
Test/examples/DataHeadParen.hs view
@@ -1,4 +1,4 @@-{-# LANGUAGE TypeOperators #-}
-module DataHeadParen where
-
-data (a1 :< a2)  = Foo
+{-# LANGUAGE TypeOperators #-}+module DataHeadParen where++data (a1 :< a2)  = Foo
Test/examples/Directory.hs view
@@ -1,4 +1,4 @@-{-# LANGUAGE ForeignFunctionInterface #-}+{-# LANGUAGE ForeignFunctionInterface, NondecreasingIndentation #-}  ----------------------------------------------------------------------------- -- |
+ Test/examples/DoRec.hs view
@@ -0,0 +1,4 @@+{-# LANGUAGE DoRec #-}++main = do rec let x = 1+          return ()
+ Test/examples/DoubleHashOp.hs view
@@ -0,0 +1,12 @@+{-# LANGUAGE UnboxedTuples #-}+module DoubleHashOp where++(##) :: a -> b -> Int+a ## b = 0++(#*) :: a -> b -> Int+a #* b = 1++-- This still does not work though:+-- (#) :: a -> b -> Int+-- a # b = 2
Test/examples/EmptyContext.hs view
@@ -1,1 +1,1 @@-happyThen :: () => P a
+happyThen :: () => P a
+ Test/examples/EmptyFunDepPremise.hs view
@@ -0,0 +1,4 @@+{-# LANGUAGE FunctionalDependencies #-}+module EmptyFunDepPremise where++class C a | -> a
Test/examples/EmptyList.hs view
@@ -1,3 +1,3 @@-module EmptyList where
-
+module EmptyList where+ eAttrs = []
− Test/examples/Ex1.hs
@@ -1,1 +0,0 @@-yes = 1 where x = 1
+ Test/examples/ExtraEndBrace.hs view
@@ -0,0 +1,3 @@+module ExtraEndBrace where++data A = B {c :: D}}
+ Test/examples/FFIExtensions.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE ForeignFunctionInterface, InterruptibleFFI, CApiFFI #-}+module FFIExtensions where++foreign import ccall interruptible+   "sleep" sleep :: CUint -> IO CUint++foreign import capi "header.h f" f :: CInt -> IO CInt
Test/examples/FamilyKindSig.hs view
@@ -1,4 +1,4 @@-{-# LANGUAGE TypeFamilies #-}
-module FamilyKindSig where
-
+{-# LANGUAGE TypeFamilies #-}+module FamilyKindSig where+ type family WithKindSig (a :: * -> *)
+ Test/examples/FamilyVarid.hs view
@@ -0,0 +1,4 @@+{-# LANGUAGE TypeFamilies #-}+module FamilyVarid where++f family forall = undefined
Test/examples/FixityTests.hs view
@@ -1,3 +1,3 @@-main = forM_ cmdReports $ \x -> do
-               putStrLn $ "Writing report to " ++ x ++ " ..."
+main = forM_ cmdReports $ \x -> do+               putStrLn $ "Writing report to " ++ x ++ " ..."                writeReport x ideas
+ Test/examples/ForallInInstance.hs view
@@ -0,0 +1,4 @@+{-# LANGUAGE ScopedTypeVariables #-}+module ForallInInstance where++instance forall a. MyClass a => MyClass [a] where
Test/examples/ForeignImport.hs view
@@ -1,4 +1,4 @@-{- If compiled without ForeignFunctionInterface (part of Haskell2010),
-   it complains not about FFI but about missing TemplateHaskell -}
-foreign import ccall unsafe "getProgArgv"
+{- If compiled without ForeignFunctionInterface (part of Haskell2010),+   it complains not about FFI but about missing TemplateHaskell -}+foreign import ccall unsafe "getProgArgv"  getProgArgv :: Ptr CInt -> Ptr (Ptr CString) -> IO ()
+ Test/examples/GADTRecord.hs view
@@ -0,0 +1,4 @@+{-# LANGUAGE GADTs #-}++data T where+  T :: { field :: Int } -> T
Test/examples/GenericTree.hs view
@@ -1,7 +1,7 @@-{-# LANGUAGE RankNTypes #-}
-module GenericTree where
-
-import Data.Typeable
-
-dynRep :: (Typeable a) => a -> (TypeRep, forall b. (Typeable b) => b -> (Maybe b))
+{-# LANGUAGE RankNTypes #-}+module GenericTree where++import Data.Typeable++dynRep :: (Typeable a) => a -> (TypeRep, forall b. (Typeable b) => b -> (Maybe b)) dynRep a = (typeOf a, \_ -> cast a)
Test/examples/GroupKeyword.hs view
@@ -1,4 +1,4 @@--- {-# LANGUAGE TransformListComp #-}
-module GroupKeyword where
-
+-- {-# LANGUAGE TransformListComp #-}+module GroupKeyword where+ a = map head $ group $ sort [1..100]
Test/examples/HappyDoAction.hs view
@@ -1,30 +1,30 @@-{-# LANGUAGE MagicHash #-}
-module HappyDoAction where
-
-foo :: Int#
-
-happyDoAction i tk st
-    = {- nothing -}
-
-
-      case action of
-        0#        -> {- nothing -}
-                     happyFail i tk st
-        -1#       -> {- nothing -}
-                     happyAccept i tk st
-        n | (n <# (0# :: Int#)) -> {- nothing -}
-
-                     (happyReduceArr ! rule) i tk st
-                     where rule = (I# ((negateInt# ((n +# (1# :: Int#))))))
-        n         -> {- nothing -}
-
-
-                     happyShift new_state i tk st
-                     where new_state = (n -# (1# :: Int#))
-   where off    = indexShortOffAddr happyActOffsets st
-         off_i  = (off +# i)
-         check  = if (off_i >=# (0# :: Int#))
-                   then (indexShortOffAddr happyCheck off_i ==#  i)
-                   else False
-         action | check     = indexShortOffAddr happyTable off_i
-                | otherwise = indexShortOffAddr happyDefActions st
+{-# LANGUAGE MagicHash #-}+module HappyDoAction where++foo :: Int#++happyDoAction i tk st+    = {- nothing -}+++      case action of+        0#        -> {- nothing -}+                     happyFail i tk st+        -1#       -> {- nothing -}+                     happyAccept i tk st+        n | (n <# (0# :: Int#)) -> {- nothing -}++                     (happyReduceArr ! rule) i tk st+                     where rule = (I# ((negateInt# ((n +# (1# :: Int#))))))+        n         -> {- nothing -}+++                     happyShift new_state i tk st+                     where new_state = (n -# (1# :: Int#))+   where off    = indexShortOffAddr happyActOffsets st+         off_i  = (off +# i)+         check  = if (off_i >=# (0# :: Int#))+                   then (indexShortOffAddr happyCheck off_i ==#  i)+                   else False+         action | check     = indexShortOffAddr happyTable off_i+                | otherwise = indexShortOffAddr happyDefActions st
Test/examples/HaskellParser.hs view
@@ -1,16 +1,16 @@-import qualified Language.Haskell.Exts.Annotated as Parser
-import qualified Language.Haskell.Exts.Annotated.Syntax as Syn
-import qualified Language.Haskell.Exts.Extension as Ext
-
-parse originalFileName input = Parser.parseModuleWithMode parseMode input
-    where
-      parseMode :: Parser.ParseMode
-      parseMode = Parser.defaultParseMode { Parser.parseFilename = originalFileName
-                                          , Parser.extensions =
-                                              Ext.glasgowExts ++
-                                              [Ext.ExplicitForall]
-                                          }
-main =
-    do s <- readFile "Bug.hs"
-       let x = parse "Bug.hs" s
-       putStrLn (show x)
+import qualified Language.Haskell.Exts.Annotated as Parser+import qualified Language.Haskell.Exts.Annotated.Syntax as Syn+import qualified Language.Haskell.Exts.Extension as Ext++parse originalFileName input = Parser.parseModuleWithMode parseMode input+    where+      parseMode :: Parser.ParseMode+      parseMode = Parser.defaultParseMode { Parser.parseFilename = originalFileName+                                          , Parser.extensions =+                                              Ext.glasgowExts +++                                              [Ext.ExplicitForall]+                                          }+main =+    do s <- readFile "Bug.hs"+       let x = parse "Bug.hs" s+       putStrLn (show x)
Test/examples/HexPrec.hs view
@@ -1,6 +1,6 @@-module HexPrec where
-
-(%%) :: Int -> Int -> Int
-a %% b = 0
-
+module HexPrec where++(%%) :: Int -> Int -> Int+a %% b = 0+ infixl 0x02 %%
− Test/examples/Hyphen.hs
@@ -1,2 +0,0 @@--foo x y = fromIntegral $ x-y+1
+ Test/examples/IllDataTypeDecl.hs view
@@ -0,0 +1,4 @@+{-# LANGUAGE TypeOperators #-}+module IllDataTypeDecl where+  +data (f :+: g) p = L
− Test/examples/ImportSymbol.hs
@@ -1,1 +0,0 @@-import Data.Generics hiding ((:*:))
Test/examples/IndentedWhere.hs view
@@ -1,4 +1,4 @@-
-f x = g
-  where g :: Int
++f x = g+  where g :: Int         g = 0
+ Test/examples/IndentedWhereBlock.hs view
@@ -0,0 +1,7 @@+module Graph where++ countryLookUp :: String -> Graph -> Maybe Int+ countryLookUp country graph = indexOf country graph where++ indexOf :: String -> Graph -> Maybe Int	+ indexOf _ Empty = Nothing
Test/examples/InfixParser.hs view
@@ -1,6 +1,6 @@-module InfixParser where
-
-type Parse a b = [a] -> [(b, [a])]
-
-(<|>) :: Parse a b -> Parse a b -> Parse a b
-(p1 <|> p2) i = p1 i ++ p2 i
+module InfixParser where++type Parse a b = [a] -> [(b, [a])]++(<|>) :: Parse a b -> Parse a b -> Parse a b+(p1 <|> p2) i = p1 i ++ p2 i
+ Test/examples/LambdaCase.hs view
@@ -0,0 +1,6 @@+{-# LANGUAGE LambdaCase #-}+module LambdaCase where++foo = \case+        Nothing -> e1+        Just e2 -> e2
− Test/examples/LanguagePragma.hs
@@ -1,1 +0,0 @@-{-# LANGUAGE PatternGuards, ViewPatterns #-}
Test/examples/LineOptionsPragma.hs view
@@ -1,3 +1,3 @@-{-# OPTIONS #-}
-{-# LINE 49 "src/Language/C/Parser/Lexer.x" #-}
+{-# OPTIONS #-}+{-# LINE 49 "src/Language/C/Parser/Lexer.x" #-} module Fail where
− Test/examples/LinePragma.hs
@@ -1,5 +0,0 @@-{-# LINE 1 "Algebra.lhs" #-}-module Algebra where--{-# LINE 3 "Algebra.lhs" #-}-foo bar = bar
− Test/examples/ListComp1.hs
@@ -1,1 +0,0 @@-copyFiles =  [a | f ('.':)]
− Test/examples/MagicHash.hs
@@ -1,12 +0,0 @@-{-# LANGUAGE MagicHash #-}--import GHC.Exts--putByteArray :: Int# -> Int#-putByteArray s# = s# +# 1#--floatFoo :: Float# -> Float-floatFoo f# = F# (f# `plusFloat#` 1.2e2#)--charFun :: Char# -> Bool-charFun c# = c# `gtChar#` 'a'#
Test/examples/MultiCtxt.hs view
@@ -1,6 +1,6 @@-{-# LANGUAGE RankNTypes #-}
-
-module MultiCtxt where
-
-multipleCtx :: Eq a => (Show a => a)
-multipleCtx = undefined
+{-# LANGUAGE RankNTypes #-}++module MultiCtxt where++multipleCtx :: Eq a => (Show a => a)+multipleCtx = undefined
+ Test/examples/MultiWayIf.hs view
@@ -0,0 +1,6 @@+{-# LANGUAGE MultiWayIf #-}+module MultiWayIf where++foo = if | test1 -> e1+         | test2 witharg -> e2+         | otherwise -> def
+ Test/examples/NegPrimWordLiteral.hs view
@@ -0,0 +1,2 @@+{-# LANGUAGE MagicHash #-}+dummyWord = W# (-0x8000000000000000##)
Test/examples/NestedAsPat.hs view
@@ -1,3 +1,3 @@-module NestedAsPat where
-
+module NestedAsPat where+ nestedAsPat [x@(Just _)] = undefined
+ Test/examples/NonDecreasing.hs view
@@ -0,0 +1,9 @@+module NonDecreasing where++-- This should not work unless NondecreasingIndentation is+-- on (which is is by default in GHC)+main = do+  print 16+  do+  print 17+  print 18
− Test/examples/PackageImport.hs
@@ -1,5 +0,0 @@-{-# LANGUAGE PackageImports #-}--import "haskell-src-exts" Language.Haskell.Exts--main = undefined
+ Test/examples/ParallelListComp.hs view
@@ -0,0 +1,3 @@+{-# LANGUAGE ParallelListComp #-}++f xs ys zs = [ (x,y,z) | x <- xs | y <- ys, y > 2 | z <- zs ]
Test/examples/ParenFunBind.hs view
@@ -1,3 +1,3 @@-module ParenFunBind where
-
+module ParenFunBind where+ (foo x) y = x + y
− Test/examples/Pragma.hs
@@ -1,7 +0,0 @@---data Bar = Bar--instance Eq Bar where-    {-# INLINE (==) #-}-    a == b = error "here"
+ Test/examples/PrimitiveIntHexLiteral.hs view
@@ -0,0 +1,2 @@+{-# LANGUAGE MagicHash #-}+minInt = I# (0x8000000000000000#)
+ Test/examples/QQType.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE FlexibleInstances, TemplateHaskell, QuasiQuotes #-}+module QQType where++import Language.Haskell.TH++x :: DecsQ+x = [d| instance Show $(conT (mkName \"Int\")) |]
Test/examples/QualifiedDot.hs view
@@ -1,3 +1,3 @@-module QualifiedDot where
-
+module QualifiedDot where+ twoDots = (Prelude..)
+ Test/examples/QuasiQuoteOld.hs view
@@ -0,0 +1,12 @@+{-# LANGUAGE QuasiQuotes #-}++import Here++str :: String+str = [$here|test +test +test test |]+++main :: IO()+main = do putStrLn str
+ Test/examples/QuasiQuoteSplice.hs view
@@ -0,0 +1,9 @@+{-# LANGUAGE TemplateHaskell, RankNTypes #-}+{-# OPTIONS_GHC -F -pgmFtrhsx #-}+import Language.Haskell.TH++data PageFunction m a = PF++main = let a = mkName "a" in+       runQ [t| forall m. PageFunction m $(conT (mkName "a")) |] >>= print+
+ Test/examples/RCategory.lhs view
@@ -0,0 +1,47 @@+\begin{code}+{-# LANGUAGE TypeFamilies, ConstraintKinds #-}+module Control.RCategory where+  ++import qualified Prelude++import GHC.Prim++infixr 9 .+infixr 1 >>>, <<<++-- | A class for categories.+--   id and (.) must form a monoid.+class RCategory cat where+  type RCategoryCtxt cat a b :: Constraint+  +  -- | the identity morphism+  id :: RCategoryCtxt cat a a +     => cat a a++  -- | morphism composition+  (.) :: (RCategoryCtxt cat b c, RCategoryCtxt cat a b, RCategoryCtxt cat a c) +      => cat b c -> cat a b -> cat a c++{-# RULES+"identity/left" forall p .+                id . p = p+"identity/right"        forall p .+                p . id = p+ #-}++instance RCategory (->) where+  type RCategoryCtxt (->) a a = ()+  id = Prelude.id+  (.) = (Prelude..)++-- | Right-to-left composition+(<<<) :: (RCategoryCtxt cat a c, RCategoryCtxt cat a b, RCategoryCtxt cat b c, RCategory cat)+      => cat b c -> cat a b -> cat a c+(<<<) = (.)++-- | Left-to-right composition+(>>>) :: (RCategoryCtxt cat a c, RCategoryCtxt cat a b, RCategoryCtxt cat b c, RCategory cat)+      => cat a b -> cat b c -> cat a c+f >>> g = g . f+\end{code}
− Test/examples/Rank2Types.hs
@@ -1,4 +0,0 @@-{-# LANGUAGE Rank2Types #-}--test :: Int -> forall a. [a] -> Int-test _ _ = 1
Test/examples/ReadP.hs view
@@ -1,2 +1,2 @@-{-# LANGUAGE TypeOperators #-}
+{-# LANGUAGE TypeOperators #-} newtype ReadP a = R (forall b . (a -> P b) -> P b)
− Test/examples/RealHSE.hs
@@ -1,898 +0,0 @@--- #hide--------------------------------------------------------------------------------- |--- Module      :  Language.Haskell.Exts.Lexer--- Copyright   :  (c) The GHC Team, 1997-2000---        (c) Niklas Broberg, 2004--- License     :  BSD-style (see the file LICENSE.txt)--- --- Maintainer  :  Niklas Broberg, d00nibro@dtek.chalmers.se--- Stability   :  experimental--- Portability :  portable------ Lexer for Haskell, with some extensions.------------------------------------------------------------------------------------- ToDo: Introduce different tokens for decimal, octal and hexadecimal (?)--- ToDo: FloatTok should have three parts (integer part, fraction, exponent) (?)--- ToDo: Use a lexical analyser generator (lx?)--module Language.Haskell.Exts.Lexer (Token(..), lexer) where--import Language.Haskell.Exts.ParseMonad--import Data.Char-import Data.Ratio--data Token-        = VarId String-        | QVarId (String,String)-        | IDupVarId (String)        -- duplicable implicit parameter-        | ILinVarId (String)        -- linear implicit parameter-        | ConId String-        | QConId (String,String)-        | DVarId [String]       -- to enable varid's with '-' in them-        | VarSym String-        | ConSym String-        | QVarSym (String,String)-        | QConSym (String,String)-        | IntTok Integer-        | FloatTok Rational-        | Character Char-        | StringTok String---- Symbols--        | LeftParen-        | RightParen-        | LeftHashParen-        | RightHashParen-        | SemiColon-        | LeftCurly-        | RightCurly-        | VRightCurly           -- a virtual close brace-        | LeftSquare-        | RightSquare-        | Comma-        | Underscore-        | BackQuote---- Reserved operators--        | Dot           -- reserved for use with 'forall x . x'-        | DotDot-        | Colon-        | DoubleColon-        | Equals-        | Backslash-        | Bar-        | LeftArrow-        | RightArrow-        | At-        | Tilde-        | DoubleArrow-        | Minus-        | Exclamation-        | Star-    --- Template Haskell-        | THExpQuote        -- [| or [e|-        | THPatQuote        -- [p|-        | THDecQuote        -- [d|-        | THTypQuote        -- [t|         -        | THCloseQuote      -- |]-        | THIdEscape (String)   -- dollar x-        | THParenEscape     -- dollar ( -        | THVarQuote        -- 'x (but without the x)-        | THTyQuote         -- ''T (but without the T)---- HaRP-        | RPGuardOpen       -- (|-        | RPGuardClose      -- |)-        | RPCAt             -- @:---- Hsx-        | XCodeTagOpen      -- <%-        | XCodeTagClose     -- %>-        | XStdTagOpen       -- <-        | XStdTagClose      -- >-        | XCloseTagOpen     -- </-        | XEmptyTagClose    -- />-        | XPCDATA String-        | XRPatOpen             -- <[-        | XRPatClose            -- ]>-        --- Pragmas--        | PragmaEnd                     -- #-}-        | PragmaUnknown (String,String)   -- Any pragma not recognized-        | RULES-        | INLINE Bool-        | SPECIALISE-        | SPECIALISE_INLINE Bool-        | SOURCE-        | DEPRECATED-        | WARNING-        | SCC-        | GENERATED-        | CORE-        | UNPACK-        | OPTIONS (Maybe String,String)-        | CFILES  String-        | LANGUAGE-        | INCLUDE String--- These are not yet implemented---        | LINE---- Reserved Ids--        | KW_As-        | KW_Case-        | KW_Class-        | KW_Data-        | KW_Default-        | KW_Deriving-        | KW_Do-        | KW_MDo-        | KW_Else-        | KW_Family     -- indexed type families-        | KW_Forall     -- universal/existential types-        | KW_Hiding-        | KW_If-        | KW_Import-        | KW_In-        | KW_Infix-        | KW_InfixL-        | KW_InfixR-        | KW_Instance-        | KW_Let-        | KW_Module-        | KW_NewType-        | KW_Of-        | KW_Then-        | KW_Type-        | KW_Where-        | KW_Qualified--                -- FFI-        | KW_Foreign-        | KW_Export-        | KW_Safe-        | KW_Unsafe-        | KW_Threadsafe-        | KW_StdCall-        | KW_CCall--        | EOF-        deriving (Eq,Show)--reserved_ops :: [(String,Token)]-reserved_ops = [- ( ".",  Dot ),- ( "..", DotDot ),- ( ":",  Colon ),- ( "::", DoubleColon ),- ( "=",  Equals ),- ( "\\", Backslash ),- ( "|",  Bar ),- ( "<-", LeftArrow ),- ( "->", RightArrow ),- ( "@",  At ),- ( "~",  Tilde ),- ( "=>", DoubleArrow ),- ( "*",  Star )- ]--special_varops :: [(String,Token)]-special_varops = [- ( "-",  Minus ),           --ToDo: shouldn't be here- ( "!",  Exclamation )      --ditto- ]--reserved_ids :: [(String,Token)]-reserved_ids = [- ( "_",         Underscore ),- ( "case",      KW_Case ),- ( "class",     KW_Class ),- ( "data",      KW_Data ),- ( "default",   KW_Default ),- ( "deriving",  KW_Deriving ),- ( "do",        KW_Do ),- ( "else",      KW_Else ),- ( "family",    KW_Family ),        -- indexed type families- ( "forall",    KW_Forall ),        -- universal/existential quantification- ( "if",        KW_If ),- ( "import",    KW_Import ),- ( "in",        KW_In ),- ( "infix",     KW_Infix ),- ( "infixl",    KW_InfixL ),- ( "infixr",    KW_InfixR ),- ( "instance",  KW_Instance ),- ( "let",       KW_Let ),- ( "mdo",       KW_MDo ),- ( "module",    KW_Module ),- ( "newtype",   KW_NewType ),- ( "of",        KW_Of ),- ( "then",      KW_Then ),- ( "type",      KW_Type ),- ( "where",     KW_Where ),---- FFI- ( "foreign",   KW_Foreign )- ]---special_varids :: [(String,Token)]-special_varids = [- ( "as",        KW_As ),- ( "qualified", KW_Qualified ),- ( "hiding",    KW_Hiding ),---- FFI- ( "export",     KW_Export),- ( "safe",       KW_Safe),- ( "unsafe",     KW_Unsafe),- ( "threadsafe", KW_Threadsafe),- ( "stdcall",    KW_StdCall),- ( "ccall",      KW_CCall)- ]--pragmas :: [(String,Token)]-pragmas = [- ( "rules",             RULES           ),- ( "inline",            INLINE True     ),- ( "noinline",          INLINE False    ),- ( "notinline",         INLINE False    ),- ( "specialise",        SPECIALISE      ),- ( "specialize",        SPECIALISE      ),- ( "source",            SOURCE          ),- ( "deprecated",        DEPRECATED      ),- ( "warning",           WARNING         ),- ( "scc",               SCC             ),- ( "generated",         GENERATED       ),- ( "core",              CORE            ),- ( "unpack",            UNPACK          ),- ( "language",          LANGUAGE        ),- ( "options",           OPTIONS undefined ), -- we'll tweak it before use - promise!- ( "cfiles",            CFILES  undefined ), -- same here...- ( "include",           INCLUDE undefined )  -- ...and here!- ]--isIdent, isHSymbol :: Char -> Bool-isIdent   c = isAlpha c || isDigit c || c == '\'' || c == '_'--isHSymbol c = c `elem` ":!#%&*./?@\\-" || ((isSymbol c || isPunctuation c) && not (c `elem` "(),;[]`{}_\"'"))--matchChar :: Char -> String -> Lex a ()-matchChar c msg = do-    s <- getInput-    if null s || head s /= c then fail msg else discard 1---- The top-level lexer.--- We need to know whether we are at the beginning of the line to decide--- whether to insert layout tokens.--lexer :: (Token -> P a) -> P a-lexer = runL $ do-    bol <- checkBOL-    (bol, ws) <- lexWhiteSpace bol-    -- take care of whitespace in PCDATA-    ec <- getExtContext-    case ec of-     -- if there was no linebreak, and we are lexing PCDATA,-     -- then we want to care about the whitespace-     Just ChildCtxt | not bol && ws -> return $ XPCDATA " "-     _ -> do startToken-             if bol then lexBOL else lexToken --lexWhiteSpace :: Bool -> Lex a (Bool, Bool)-lexWhiteSpace bol = do-    s <- getInput-    case s of-        '{':'-':'#':_ -> do-            return (bol, False)-        '{':'-':_ -> do-            discard 2-            bol <- lexNestedComment bol-            (bol, _) <- lexWhiteSpace bol-            return (bol, True)-        '-':'-':s | all (== '-') (takeWhile isHSymbol s) -> do-            lexWhile (== '-')-            lexWhile (/= '\n')-            s' <- getInput-            case s' of-                [] -> fail "Unterminated end-of-line comment"-                _ -> do-                    lexNewline-                    lexWhiteSpace True-                    return (True, True)-        '\n':_ -> do-            lexNewline-            lexWhiteSpace True-            return (True, True)-        '\t':_ -> do-            lexTab-            (bol, _) <- lexWhiteSpace bol-            return (bol, True)      -        c:_ | isSpace c -> do-            discard 1-            (bol, _) <- lexWhiteSpace bol-            return (bol, True)-        _ -> return (bol, False)--lexNestedComment :: Bool -> Lex a Bool-lexNestedComment bol = do-    s <- getInput-    case s of-        '-':'}':_ -> discard 2 >> return bol-        '{':'-':_ -> do-            discard 2-            bol <- lexNestedComment bol -- rest of the subcomment-            lexNestedComment bol        -- rest of this comment-        '\t':_    -> lexTab >> lexNestedComment bol-        '\n':_    -> lexNewline >> lexNestedComment True-        _:_       -> discard 1 >> lexNestedComment bol-        []        -> fail "Unterminated nested comment"---- When we are lexing the first token of a line, check whether we need to--- insert virtual semicolons or close braces due to layout.--lexBOL :: Lex a Token-lexBOL = do-    pos <- getOffside-    case pos of-        LT -> do-                -- trace "layout: inserting '}'\n" $-            -- Set col to 0, indicating that we're still at the-            -- beginning of the line, in case we need a semi-colon too.-            -- Also pop the context here, so that we don't insert-            -- another close brace before the parser can pop it.-            setBOL-            popContextL "lexBOL"-            return VRightCurly-        EQ ->-            -- trace "layout: inserting ';'\n" $-            return SemiColon-        GT -> lexToken--lexToken :: Lex a Token-lexToken = do-    ec <- getExtContext-    case ec of-     Just HarpCtxt     -> lexHarpToken-     Just TagCtxt      -> lexTagCtxt-     Just CloseTagCtxt -> lexCloseTagCtxt-     Just ChildCtxt    -> lexChildCtxt-     Just CodeTagCtxt  -> lexCodeTagCtxt-     _         -> lexStdToken---lexChildCtxt :: Lex a Token-lexChildCtxt = do-    s <- getInput-    case s of-        '<':'%':_ -> do discard 2-                        pushExtContextL CodeTagCtxt-                        return XCodeTagOpen-        '<':'/':_ -> do discard 2-                        popExtContextL "lexChildCtxt"-                        pushExtContextL CloseTagCtxt-                        return XCloseTagOpen-        '<':'[':_ -> do discard 2-                        pushExtContextL HarpCtxt-                        return XRPatOpen-        '<':_     -> do discard 1-                        pushExtContextL TagCtxt-                        return XStdTagOpen-        _     -> lexPCDATA---lexPCDATA :: Lex a Token-lexPCDATA = do-    s <- getInput-    case s of-        [] -> return EOF-        _  -> case s of-            '\n':_ -> do-                x <- lexNewline >> lexPCDATA-                case x of-                 XPCDATA p -> return $ XPCDATA $ '\n':p-                 EOF -> return EOF-            '<':_ -> return $ XPCDATA ""-            _ -> do let pcd = takeWhile (\c -> not $ elem c "<\n") s-                        l = length pcd-                    discard l-                    x <- lexPCDATA-                    case x of-                     XPCDATA pcd' -> return $ XPCDATA $ pcd ++ pcd'-                     EOF -> return EOF---lexCodeTagCtxt :: Lex a Token-lexCodeTagCtxt = do-    s <- getInput-    case s of-        '%':'>':_ -> do discard 2-                        popExtContextL "lexCodeTagContext"-                        return XCodeTagClose-        _     -> lexStdToken--lexCloseTagCtxt :: Lex a Token-lexCloseTagCtxt = do-    s <- getInput-    case s of-        '>':_     -> do discard 1-                        popExtContextL "lexCloseTagCtxt"-                        return XStdTagClose-        _     -> lexStdToken--lexTagCtxt :: Lex a Token-lexTagCtxt = do-    s <- getInput-    case s of-        '/':'>':_ -> do discard 2-                        popExtContextL "lexTagCtxt: Empty tag"-                        return XEmptyTagClose-        '>':_     -> do discard 1-                        popExtContextL "lexTagCtxt: Standard tag"-                        pushExtContextL ChildCtxt-                        return XStdTagClose-        _     -> lexStdToken--lexHarpToken :: Lex a Token-lexHarpToken = do-    s <- getInput-    case s of-        ']':'>':_ -> do discard 2-                        popExtContextL "lexHarpToken"-                        return XRPatClose-        _     -> lexStdToken--lexStdToken :: Lex a Token-lexStdToken = do-    s <- getInput-    case s of-        [] -> return EOF--        '0':c:d:_ | toLower c == 'o' && isOctDigit d -> do-                        discard 2-                        n <- lexOctal-                        return (IntTok n)-                  | toLower c == 'x' && isHexDigit d -> do-                        discard 2-                        n <- lexHexadecimal-                        return (IntTok n)-    -        -- implicit parameters-        '?':c:_ | isLower c -> do-                        discard 1-                        id <- lexWhile isIdent-                        return $ IDupVarId id--        '%':c:_ | isLower c -> do-                        discard 1-                        id <- lexWhile isIdent-                        return $ ILinVarId id-        -- end implicit parameters--        -- harp-        '(':'|':c:_  | isHSymbol c -> discard 1 >> return LeftParen-        '(':'|':_ -> do discard 2-                        return RPGuardOpen-        '|':')':_ -> do discard 2-                        return RPGuardClose-        '@':':':_ -> do discard 2-                        return RPCAt-    -        -- template haskell-        '[':'|':_ -> do-                discard 2-                return $ THExpQuote-    -        '[':c:'|':_ | c == 'e' -> do-                        discard 3-                        return $ THExpQuote-                    | c == 'p' -> do-                        discard 3-                        return THPatQuote-                    | c == 'd' -> do-                        discard 3-                        return THDecQuote-                    | c == 't' -> do-                        discard 3-                        return THTypQuote-                -        '|':']':_ -> do discard 2-                        return THCloseQuote-              -        '$':c:_ | isLower c -> do-                        discard 1-                        id <- lexWhile isIdent-                        return $ THIdEscape id-                | c == '(' -> do-                        discard 2-                        return THParenEscape-        -- end template haskell-    -        -- hsx-        '<':'%':_ -> do discard 2-                        pushExtContextL CodeTagCtxt-                        return XCodeTagOpen-        '<':c:_ | isAlpha c -> do discard 1-                                  pushExtContextL TagCtxt-                                  return XStdTagOpen-        -- end hsx-    -        '(':'#':_ -> do discard 2 >> return LeftHashParen-    -        '#':')':_ -> do discard 2 >> return RightHashParen-        -        -- pragmas-        -        '{':'-':'#':_ -> do discard 3 >> lexPragmaStart-        -        '#':'-':'}':_ -> do discard 3 >> return PragmaEnd-    -        c:_ | isDigit c -> lexDecimalOrFloat--            | isUpper c -> lexConIdOrQual ""--            | isLower c || c == '_' -> do-                    idents <- lexIdents-                    case idents of-                     [ident] -> return $ case lookup ident (reserved_ids ++ special_varids) of-                                          Just keyword -> keyword-                                          Nothing -> VarId ident-                     _ -> return $ DVarId idents--            | isHSymbol c -> do-                    sym <- lexWhile isHSymbol-                    return $ case lookup sym (reserved_ops ++ special_varops) of-                              Just t  -> t-                              Nothing -> case c of-                                          ':' -> ConSym sym-                                          _   -> VarSym sym--            | otherwise -> do-                    discard 1-                    case c of--                        -- First the special symbols-                        '(' ->  return LeftParen-                        ')' ->  return RightParen-                        ',' ->  return Comma-                        ';' ->  return SemiColon-                        '[' ->  return LeftSquare-                        ']' ->  return RightSquare-                        '`' ->  return BackQuote-                        '{' -> do-                            pushContextL NoLayout-                            return LeftCurly-                        '}' -> do-                            popContextL "lexStdToken"-                            return RightCurly--                        '\'' -> lexCharacter-                        '"' ->  lexString--                        _ ->    fail ("Illegal character \'" ++ show c ++ "\'\n")--      where lexIdents :: Lex a [String]-            lexIdents = do-                ident <- lexWhile isIdent-                s <- getInput-                case s of-                 '-':c:_ | isAlpha c -> do -                        discard 1-                        idents <- lexIdents-                        return $ ident : idents-                 '#':_ -> do-                        discard 1-                        return [ident ++ "#"]-                 _ -> return [ident]---lexPragmaStart :: Lex a Token-lexPragmaStart = do-    lexWhile isSpace-    pr <- lexWhile isAlphaNum-    case lookup (map toLower pr) pragmas of-     Just SPECIALISE -> do-            s <- getInput-            case dropWhile isSpace $ map toLower s of-             'i':'n':'l':'i':'n':'e':_ -> do-                      lexWhile isSpace-                      discard 6-                      return $ SPECIALISE_INLINE True-             'n':'o':'i':'n':'l':'i':'n':'e':_ -> do-                        lexWhile isSpace-                        discard 8-                        return $ SPECIALISE_INLINE False-             'n':'o':'t':'i':'n':'l':'i':'n':'e':_ -> do-                        lexWhile isSpace-                        discard 9-                        return $ SPECIALISE_INLINE False-             _ -> return SPECIALISE-              -     Just (OPTIONS _) -> do     -- see, I promised we'd mask out the 'undefined'-            s <- getInput-            case s of-             '_':_  -> do-                discard 1-                com <- lexWhile isIdent-                rest <- lexRawPragma-                return $ OPTIONS (Just com, rest)-             x:_ | isSpace x -> do-                rest <- lexRawPragma-                return $ OPTIONS (Nothing, rest)-             _ -> fail "Malformed Options pragma"-     Just (CFILES _) -> do-            rest <- lexRawPragma-            return $ CFILES rest-     Just (INCLUDE _) -> do-            rest <- lexRawPragma-            return $ INCLUDE rest-     Just p ->  return p--     _      -> do rawStr <- lexRawPragma-                  return $ PragmaUnknown (pr, rawStr)--lexRawPragma :: Lex a String-lexRawPragma = do-    rpr <- lexRawPragmaAux-    return $ dropWhile isSpace rpr- where lexRawPragmaAux = do-        rpr <- lexWhile (/='#')-        s <- getInput-        case s of-         '#':'-':'}':_  -> return rpr-         _ -> do -            discard 1-            rpr' <- lexRawPragma-            return $ rpr ++ '#':rpr'--lexDecimalOrFloat :: Lex a Token-lexDecimalOrFloat = do-    ds <- lexWhile isDigit-    rest <- getInput-    case rest of-        ('.':d:_) | isDigit d -> do-                discard 1-                frac <- lexWhile isDigit-                let num = parseInteger 10 (ds ++ frac)-                    decimals = toInteger (length frac)-                exponent <- do-                    rest2 <- getInput-                    case rest2 of-                        'e':_ -> lexExponent-                        'E':_ -> lexExponent-                        _     -> return 0-                return (FloatTok ((num%1) * 10^^(exponent - decimals)))-        e:_ | toLower e == 'e' -> do-                exponent <- lexExponent-                return (FloatTok ((parseInteger 10 ds%1) * 10^^exponent))-        _ -> return (IntTok (parseInteger 10 ds))--    where-    lexExponent :: Lex a Integer-    lexExponent = do-        discard 1   -- 'e' or 'E'-        r <- getInput-        case r of-         '+':d:_ | isDigit d -> do-            discard 1-            lexDecimal-         '-':d:_ | isDigit d -> do-            discard 1-            n <- lexDecimal-            return (negate n)-         d:_ | isDigit d -> lexDecimal-         _ -> fail "Float with missing exponent"--lexConIdOrQual :: String -> Lex a Token-lexConIdOrQual qual = do-        con <- lexWhile isIdent-        let conid | null qual = ConId con-                  | otherwise = QConId (qual,con)-            qual' | null qual = con-                  | otherwise = qual ++ '.':con-        just_a_conid <- alternative (return conid)-        rest <- getInput-        case rest of-          '.':c:_-             | isLower c || c == '_' -> do  -- qualified varid?-                    discard 1-                    ident <- lexWhile isIdent-                    s <- getInput-                    ident' <- case s of-                               '#':_ -> discard 1 >> return (ident ++ "#")-                               _ -> return ident-                    case lookup ident' reserved_ids of-                       -- cannot qualify a reserved word-                       Just _  -> just_a_conid-                       Nothing -> return (QVarId (qual', ident'))--             | isUpper c -> do      -- qualified conid?-                    discard 1-                    lexConIdOrQual qual'--             | isHSymbol c -> do    -- qualified symbol?-                    discard 1-                    sym <- lexWhile isHSymbol-                    case lookup sym reserved_ops of-                        -- cannot qualify a reserved operator-                        Just _  -> just_a_conid-                        Nothing -> return $ case c of-                                              ':' -> QConSym (qual', sym)-                                              _   -> QVarSym (qual', sym)--          '#':c:_ -            | isSpace c -> do-                discard 1-                case conid of-                 ConId con -> return $ ConId $ con ++ "#"-                 QConId (q,con) -> return $ QConId (q,con ++ "#")-          _ ->  return conid -- not a qualified thing--lexCharacter :: Lex a Token-lexCharacter = do   -- We need to keep track of not only character constants but also TH 'x and ''T-        -- We've seen ' so far-        s <- getInput-        case s of-         '\'':_ -> discard 1 >> return THTyQuote-         '\\':_ -> do -                    c <- lexEscape -                    matchQuote-                    return (Character c)-         c:'\'':_ -> discard 2 >> return (Character c)-         _ -> return THVarQuote                    --    where matchQuote = matchChar '\'' "Improperly terminated character constant"---lexString :: Lex a Token-lexString = loop ""-    where-    loop s = do-        r <- getInput-        case r of-            '\\':'&':_ -> do-                    discard 2-                    loop s-            '\\':c:_ | isSpace c -> do-                        discard 1-                        lexWhiteChars-                        matchChar '\\' "Illegal character in string gap"-                        loop s-                     | otherwise -> do-                        ce <- lexEscape-                        loop (ce:s)-            '"':_ -> do-                discard 1-                return (StringTok (reverse s))-            c:_ -> do-                discard 1-                loop (c:s)-            [] ->   fail "Improperly terminated string"--    lexWhiteChars :: Lex a ()-    lexWhiteChars = do-        s <- getInput-        case s of-            '\n':_ -> do-                    lexNewline-                    lexWhiteChars-            '\t':_ -> do-                    lexTab-                    lexWhiteChars-            c:_ | isSpace c -> do-                    discard 1-                    lexWhiteChars-            _ -> return ()--lexEscape :: Lex a Char-lexEscape = do-    discard 1-    r <- getInput-    case r of---- Production charesc from section B.2 (Note: \& is handled by caller)--        'a':_           -> discard 1 >> return '\a'-        'b':_           -> discard 1 >> return '\b'-        'f':_           -> discard 1 >> return '\f'-        'n':_           -> discard 1 >> return '\n'-        'r':_           -> discard 1 >> return '\r'-        't':_           -> discard 1 >> return '\t'-        'v':_           -> discard 1 >> return '\v'-        '\\':_          -> discard 1 >> return '\\'-        '"':_           -> discard 1 >> return '\"'-        '\'':_          -> discard 1 >> return '\''---- Production ascii from section B.2--        '^':c:_         -> discard 2 >> cntrl c-        'N':'U':'L':_   -> discard 3 >> return '\NUL'-        'S':'O':'H':_   -> discard 3 >> return '\SOH'-        'S':'T':'X':_   -> discard 3 >> return '\STX'-        'E':'T':'X':_   -> discard 3 >> return '\ETX'-        'E':'O':'T':_   -> discard 3 >> return '\EOT'-        'E':'N':'Q':_   -> discard 3 >> return '\ENQ'-        'A':'C':'K':_   -> discard 3 >> return '\ACK'-        'B':'E':'L':_   -> discard 3 >> return '\BEL'-        'B':'S':_       -> discard 2 >> return '\BS'-        'H':'T':_       -> discard 2 >> return '\HT'-        'L':'F':_       -> discard 2 >> return '\LF'-        'V':'T':_       -> discard 2 >> return '\VT'-        'F':'F':_       -> discard 2 >> return '\FF'-        'C':'R':_       -> discard 2 >> return '\CR'-        'S':'O':_       -> discard 2 >> return '\SO'-        'S':'I':_       -> discard 2 >> return '\SI'-        'D':'L':'E':_   -> discard 3 >> return '\DLE'-        'D':'C':'1':_   -> discard 3 >> return '\DC1'-        'D':'C':'2':_   -> discard 3 >> return '\DC2'-        'D':'C':'3':_   -> discard 3 >> return '\DC3'-        'D':'C':'4':_   -> discard 3 >> return '\DC4'-        'N':'A':'K':_   -> discard 3 >> return '\NAK'-        'S':'Y':'N':_   -> discard 3 >> return '\SYN'-        'E':'T':'B':_   -> discard 3 >> return '\ETB'-        'C':'A':'N':_   -> discard 3 >> return '\CAN'-        'E':'M':_       -> discard 2 >> return '\EM'-        'S':'U':'B':_   -> discard 3 >> return '\SUB'-        'E':'S':'C':_   -> discard 3 >> return '\ESC'-        'F':'S':_       -> discard 2 >> return '\FS'-        'G':'S':_       -> discard 2 >> return '\GS'-        'R':'S':_       -> discard 2 >> return '\RS'-        'U':'S':_       -> discard 2 >> return '\US'-        'S':'P':_       -> discard 2 >> return '\SP'-        'D':'E':'L':_   -> discard 3 >> return '\DEL'---- Escaped numbers--        'o':c:_ | isOctDigit c -> do-                    discard 1-                    n <- lexOctal-                    checkChar n-        'x':c:_ | isHexDigit c -> do-                    discard 1-                    n <- lexHexadecimal-                    checkChar n-        c:_ | isDigit c -> do-                    n <- lexDecimal-                    checkChar n--        _       -> fail "Illegal escape sequence"--    where-    checkChar n | n <= 0x01FFFF = return (chr (fromInteger n))-    checkChar _                 = fail "Character constant out of range"---- Production cntrl from section B.2--    cntrl :: Char -> Lex a Char-    cntrl c | c >= '@' && c <= '_' = return (chr (ord c - ord '@'))-    cntrl _                        = fail "Illegal control character"---- assumes at least one octal digit-lexOctal :: Lex a Integer-lexOctal = do-    ds <- lexWhile isOctDigit-    return (parseInteger 8 ds)---- assumes at least one hexadecimal digit-lexHexadecimal :: Lex a Integer-lexHexadecimal = do-    ds <- lexWhile isHexDigit-    return (parseInteger 16 ds)---- assumes at least one decimal digit-lexDecimal :: Lex a Integer-lexDecimal = do-    ds <- lexWhile isDigit-    return (parseInteger 10 ds)---- Stolen from Hugs's Prelude-parseInteger :: Integer -> String -> Integer-parseInteger radix ds =-    foldl1 (\n d -> n * radix + d) (map (toInteger . digitToInt) ds)
− Test/examples/RealHoogle.hs
@@ -1,254 +0,0 @@-{-|-    Parse a list of flags supported in any of the front ends.--    Returns the flags in a data structure, along with any invalid flags.-    -    Deal with any files/include files in this stage.--}--module CmdLine.Flag(-    CmdFlag(..), flagsHelp,-    flagsWebArgs, flagsWebQuery, flagsCmdLine-    ) where--import General.Code-import General.Glob-------------------------------------------------------------------------- The flags--data CmdFlag = Version           -- ^ Version information-             | Web               -- ^ Operate as a CGI process-             | Help              -- ^ Help text-             | Test              -- ^ Run the regression tests-             | Color Bool        -- ^ Colors on the console-             | Start Int         -- ^ First result to show-             | Count Int         -- ^ Number of results to show-             | Convert FilePath  -- ^ Convert a database-             | Output FilePath   -- ^ Output file-             | Dump String       -- ^ Dump a database to a file (optional section)-             | DataFile FilePath -- ^ Database location-             | Verbose           -- ^ Display verbose information-             | Info              -- ^ Display as much information as you can-             | Debug             -- ^ Do debugging activities-             | Include FilePath  -- ^ Include directory-             | TestFile FilePath -- ^ Run tests in a file-             | Rank FilePath     -- ^ Generate rankings-             | Combine FilePath  -- ^ Merge a set of databases-             | Mode String       -- ^ Web modes-               deriving (Show,Eq {-! Enum !-} )----- | In which circumstances are you allowed to pass this command-data Permission = PWebArgs | PWebQuery | PCmdLine | PMultiple-                  deriving (Show,Eq)--data Argument = ArgNone CmdFlag-              | ArgBool (Bool     -> CmdFlag)-              | ArgInt  (Int      -> CmdFlag)-              | ArgNat  (Int      -> CmdFlag)-              | ArgPos  (Int      -> CmdFlag)-              | ArgFileIn (FilePath -> CmdFlag) [String]-              | ArgFileOut (FilePath -> CmdFlag)-              | ArgDir (FilePath -> CmdFlag)-              | ArgStr  (String   -> CmdFlag)--instance Show Argument where-    show (ArgNone _) = ""-    show (ArgInt  _) = "INT"-    show (ArgNat  _) = "NAT"-    show (ArgPos  _) = "POS"-    show (ArgBool _) = "BOOL"-    show (ArgFileIn _ _) = "FILE"-    show (ArgFileOut _) = "FILE"-    show (ArgDir _) = "DIR"-    show (ArgStr  _) = "STR"---data FlagInfo = FlagInfo {-    argument :: Argument,-    names :: [String],-    permissions :: [Permission],-    description :: String-    }--flagInfo =-    [f (ArgNone Version) ["version","ver"] [PCmdLine] "Print out version information"-    ,f (ArgNone Help) ["?","help","h"] [PCmdLine] "Show help message"-    ,f (ArgNone Web) ["w","web"] [PCmdLine] "Run as though it was a CGI script"-    ,f (ArgBool Color) ["c","color","col","colour"] [PCmdLine] "Show color output (default=false)"-    ,f (ArgPos  Start) ["s","start"] [PCmdLine,PWebArgs] "First result to show (default=1)"-    ,f (ArgPos  Count) ["n","count","length","len"] [PCmdLine,PWebArgs] "Number of results to show (default=all)"-    ,f (ArgNone Test) ["test"] [PCmdLine] "Run the regression tests"-    ,f (ArgFileIn Convert ["txt"]) ["convert"] [PCmdLine,PMultiple] "Convert a database"-    ,f (ArgFileOut Output) ["output"] [PCmdLine] "Output file for convert"-    ,f (ArgStr  Dump) ["dump"] [PCmdLine] "Dump a database for debugging"-    ,f (ArgFileIn DataFile ["hoo"]) ["d","data"] [PCmdLine,PMultiple] "Database file"-    ,f (ArgNone Verbose) ["v","verbose"] [PCmdLine] "Display verbose information"-    ,f (ArgNone Info) ["info"] [PCmdLine] "Display full information on an entry"-    ,f (ArgNone Debug) ["debug"] [PCmdLine] "Debugging only"-    ,f (ArgDir Include) ["i","include"] [PCmdLine,PMultiple] "Include directories"-    ,f (ArgFileIn TestFile ["txt"]) ["testfile"] [PCmdLine,PMultiple] "Run tests from a file"-    ,f (ArgFileIn Rank ["txt"]) ["rank"] [PCmdLine,PMultiple] "Generate ranking scores"-    ,f (ArgFileIn Combine ["hoo"]) ["combine"] [PCmdLine,PMultiple] "Combine multiple databases"-    ,f (ArgStr Mode) ["mode"] [PCmdLine,PWebArgs] "Web mode"-    ]-    where f = FlagInfo---cmdFlagBadArg flag typ "" = "Missing argument to flag " ++ flag ++ ", expected argument of type " ++ typ-cmdFlagBadArg flag "" x = "Unexpected argument to flag " ++ flag ++ ", got \"" ++ x ++ "\""-cmdFlagBadArg flag typ x = "Bad argument to flag " ++ flag ++ ", expected argument of type " ++ typ ++ ", got \"" ++ x ++ "\""--cmdFlagPermission flag = "Flag not allowed when running in this mode, flag " ++ flag--cmdFlagUnknown flag = "Unknown flag " ++ flag--cmdFlagDuplicate flag = "The flag " ++ flag ++ " may only occur once, but occured multiple times"--------------------------------------------------------------------------- Operations on Flags---- | flags that are passed in through web arguments,---   i.e. ?foo=bar&...-flagsWebArgs :: [(String,String)] -> IO ([CmdFlag],[String])-flagsWebArgs = parseFlags PWebArgs----- | flags that are given in the web query string-flagsWebQuery :: [(String,String)] -> IO ([CmdFlag],[String])-flagsWebQuery = parseFlags PWebQuery----- | flags that are given in a query on the command line-flagsCmdLine :: [(String,String)] -> IO ([CmdFlag],[String])-flagsCmdLine = parseFlags PCmdLine---flagsHelp :: String-flagsHelp = unlines $ map f res-    where-        f (a,b,c) = "  " ++ (if null a then "    " else "--" ++ a ++ ",") ++-                    " --" ++ b ++ replicate (maxLong - length b) ' ' ++-                    "  " ++ c--        maxLong = maximum $ map (length . snd3) res-        res = [ (shortOpt (names i), longOpt (names i) ++ typ (argument i), description i)-              | i <- flagInfo, PCmdLine `elem` permissions i]--        shortOpt ([x]:_) = [x]-        shortOpt _ = ""-        -        longOpt ([_]:x:_) = x-        longOpt (x:_) = x--        typ x = ['='|s/=""] ++ s-            where s = show x--------------------------------------------------------------------------- Parsing Flags---- TODO: check no flag is specified twice--- TODO: Fix a bug, try /merge=t1;t2 and you get [t1,t1,t2,t2]-parseFlags :: Permission -> [(String,String)] -> IO ([CmdFlag],[String])-parseFlags perm xs = do-    let args = concatMap (parseFlag perm) xs-        inc = [x | Right (_,_,_,Include x) <- args]-    incs <- mapM globDir $ ["."|null inc] ++ inc-    (a,b) <- mapAndUnzipM (f incs) args-    return ([Include "."|null inc] ++ concat a, concat b)-    where-        f inc (Right (_,val,FlagInfo{argument=ArgFileIn gen exts},_)) = do-            let vals = parseFile val-            files <- concatMapM (globFile inc exts) vals-            return (map gen files, [])-        f inc (Left v) = return ([],[v])-        f inc (Right (_,_,_,v)) = return ([v],[])----- does all validity checks apart from checking for duplicate flags-parseFlag :: Permission -> (String, String) -> [Either String (String,String,FlagInfo,CmdFlag)]-parseFlag perm (key,val)-        | isNothing m = [Left $ cmdFlagUnknown key]-        | perm `notElem` permissions flg = [Left $ cmdFlagPermission key]-        | null arg = [Left $ cmdFlagBadArg key (show $ argument flg) val]-        | otherwise = [Right (key,val,flg,a) | a <- arg]-    where-        key2 = lower key-        m@ ~(Just flg) = listToMaybe [i | i <- flagInfo, key2 `elem` names i]-        arg = parseArg (argument flg) val---parseArg :: Argument -> String -> [CmdFlag]-parseArg (ArgNone v) xs = [v | null xs]-parseArg (ArgStr  v) xs = [v xs]-parseArg (ArgBool v) xs = map v $ parseBool xs-parseArg (ArgNat  v) xs = map v $ parseNat  xs-parseArg (ArgInt  v) xs = map v $ parseInt  xs-parseArg (ArgPos  v) xs = map v $ parsePos  xs-parseArg (ArgFileIn v _) xs = map v $ parseFile xs-parseArg (ArgFileOut v) xs = map v $ parseFile xs-parseArg (ArgDir v) xs = map v $ parseFile xs---parseNat, parsePos, parseInt :: String -> [Int]-parseNat = filter (>= 0) . parseInt-parsePos = filter (> 0) . parseInt-parseInt x = [a | (a,"") <- reads x]--parseFile :: String -> [String]-parseFile = splitSearchPath--parseBool :: String -> [Bool]-parseBool v | v2 `elem` ["","on","yes","1","true","meep"] = [True]-            | v2 `elem` ["off","no","0","false","moop"] = [False]-            | otherwise = []-    where v2 = lower v--------------------------------------------------------------- DERIVES GENERATED CODE--- DO NOT MODIFY BELOW THIS LINE--- CHECKSUM: 1401092643--instance Enum CmdFlag-    where toEnum 0 = Version{}-          toEnum 1 = Web{}-          toEnum 2 = Help{}-          toEnum 3 = Test{}-          toEnum 4 = Color{}-          toEnum 5 = Start{}-          toEnum 6 = Count{}-          toEnum 7 = Convert{}-          toEnum 8 = Output{}-          toEnum 9 = Dump{}-          toEnum 10 = DataFile{}-          toEnum 11 = Verbose{}-          toEnum 12 = Info{}-          toEnum 13 = Debug{}-          toEnum 14 = Include{}-          toEnum 15 = TestFile{}-          toEnum 16 = Rank{}-          toEnum 17 = Combine{}-          toEnum n = error ((++) "toEnum " ((++) (show n) ", not defined for CmdFlag"))-          fromEnum (Version {}) = 0-          fromEnum (Web {}) = 1-          fromEnum (Help {}) = 2-          fromEnum (Test {}) = 3-          fromEnum (Color {}) = 4-          fromEnum (Start {}) = 5-          fromEnum (Count {}) = 6-          fromEnum (Convert {}) = 7-          fromEnum (Output {}) = 8-          fromEnum (Dump {}) = 9-          fromEnum (DataFile {}) = 10-          fromEnum (Verbose {}) = 11-          fromEnum (Info {}) = 12-          fromEnum (Debug {}) = 13-          fromEnum (Include {}) = 14-          fromEnum (TestFile {}) = 15-          fromEnum (Rank {}) = 16-          fromEnum (Combine {}) = 17
− Test/examples/RealTagSoup.hs
@@ -1,395 +0,0 @@-{-# OPTIONS_GHC -w #-}--{--The XML spec is done mainly from memory. The only special bits are:--Attributes-------------"foo" as an attribute comes out as an attribute with a value and no text-to allow DOCTYPE tags to get parsed as normal.--References (aka Character and Entity References)-------------A character reference is one of:--entity = '&#' [0-9]+ ';' -       | '&#x' [0-9a-fA-F]+ ';'-       | '&' name ';'--The maximum character reference is 0x10FFFF--name = (letter | '_' | ':') (namechar)*-namechar = letter | digit | '.' | '-' | '_' | ':' | combiningchar | extender-combiningchar and extender are assumed to be empty-letter = isAlpha-digit = isDigit--}---module Text.HTML.TagSoup.Parser(-    parseTags, parseTagsOptions,-    ParseOptions(..), parseOptions-    ) where--import Text.HTML.TagSoup.Type-import Text.HTML.TagSoup.Entity-import Control.Monad.State-import Data.Char-import Data.List-import Data.Maybe---infix 9 ?->--(?->) :: Bool -> [x] -> [x]-(?->) b true = if b then true else []-------------------------------------------------------------------------- * ParseOptions--data ParseOptions = ParseOptions-    {optTagPosition :: Bool -- ^ Should 'TagPosition' values be given before every item-    ,optTagWarning :: Bool -- ^ Should 'TagWarning' values be given-    ,optLookupEntity :: String -> [Tag] -- ^ How to lookup an entity-    ,optMaxEntityLength :: Maybe Int -- ^ The maximum length of an entities content-                                     --   (Nothing for no maximum, default to 10)-    }----- Default 'ParseOptions' structure-parseOptions :: ParseOptions-parseOptions = ParseOptions False False f (Just 10)-    where-        f x = case lookupEntity x of-                  Nothing -> [TagText $ "&" ++ x ++ ";", TagWarning $ "Unknown entity: &" ++ x ++ ";"]-                  Just x -> [TagText [x]]---parseTags :: String -> [Tag]-parseTags = parseTagsOptions parseOptions--tagWarn :: ParseOptions -> String -> [Tag]-tagWarn opts x = [TagWarning x | optTagWarning opts]-------------------------------------------------------------------------- * Positions---- All positions are stored as a row and a column, with (1,1) being the--- top-left position--data Position = Position !Row !Column---updateOnString :: Position -> String -> Position-updateOnString = foldl' updateOnChar--updateOnChar   :: Position -> Char -> Position-updateOnChar (Position r c) x = case x of-    '\n' -> Position (r+1) c-    '\t' -> Position r (c + 8 - mod (c-1) 8)-    _    -> Position r (c+1)---tagPos :: ParseOptions -> Position -> [Tag]-tagPos opts (Position r c) = [TagPosition r c | optTagPosition opts]--tagPosWarn :: ParseOptions -> Position -> String -> [Tag]-tagPosWarn opts p x = optTagWarning opts ?-> (tagPos opts p ++ [TagWarning x])--tagPosWarnFix :: ParseOptions -> Position -> [Tag] -> [Tag]-tagPosWarnFix opts p = addPositions . remWarnings-    where-        remWarnings = if optTagWarning opts then id else filter (not . isTagWarning)-        addPositions = concatMap (\x -> tagPos opts p ++ [x])-    -------------------------------------------------------------------------- * Driver--parseTagsOptions :: ParseOptions -> String -> [Tag]-parseTagsOptions opts x = mergeTexts $ evalState (parse opts) $ Value x (Position 0 0)----- | Combine adjacent text nodes.------   If two text nodes are separated only a position node, delete the position.---   If two text nodes are separated only by a warning, move the warning afterwards.---   If a position immediately proceeds a warning, count that into the warning.------   Note: this function leaks stack on Hugs.-mergeTexts :: [Tag] -> [Tag]-mergeTexts (TagText x:xs) = (TagText $ concat $ x:texts) : warns ++ mergeTexts rest-    where-        (texts,warns,rest) = f xs--        f (TagText x:xs) = (x:a,b,c)-            where (a,b,c) = f xs-        f (TagPosition _ _:TagText x:xs) = (x:a,b,c)-            where (a,b,c) = f xs--        f (p@TagPosition{}:TagWarning y:xs) = (a,p:TagWarning y:b,c)-            where (a,b,c) = f xs-        f (TagWarning x:xs) = (a,TagWarning x:b,c)-            where (a,b,c) = f xs--        f xs = ([],[],xs)--mergeTexts (x:xs) = x : mergeTexts xs-mergeTexts [] = []--------------------------------------------------------------------------- * Combinators--data Value = Value String !Position--type Parser a = State Value a---isNameCharFirst x = isAlphaNum x || x `elem` "_:"-isNameChar x = isAlphaNum x || x `elem` "-_:."---- Read and consume n characters from the stream, updating the position.--- Highly likely to be a potential for space leaks from this, unless @n@ is bounded.-consume :: Int -> Parser ()-consume n = do-    Value s p <- get-    let (a,b) = splitAt n s-    put $ Value b (updateOnString p a)----- Break once an end string is encountered.--- Return the string before, and a boolean indicating if the end was matched.-breakOn :: String -> Parser (String,Bool)-breakOn end = do-    Value s p <- get-    if null s then-        return ("",True)-     else if end `isPrefixOf` s then-        consume (length end) >> return ("",False)-     else do-        consume 1-        ~(a,b) <- breakOn end-        return (head s:a,b)---- Break after an HTML name (entity, attribute or tag name)--- Note: potential space leak with consume at the end-breakName :: Parser String-breakName = do-    Value s p <- get-    if not (null s) && isNameCharFirst (head s) then do-        let (a,b) = span isNameChar s-        consume (length a)-        return a-     else-        return ""---- Break after a number has been read--- Note: potential space leak with consume at the end-breakNumber :: Parser (Maybe Int)-breakNumber = do-    Value s p <- get-    if not (null s) && isDigit (head s) then do-        let (a,b) = span isDigit s-        consume (length a)-        return $ Just $ read a-     else-        return Nothing----- Drop a number of spaces--- Note: potential space leak with consume at the end-dropSpaces :: Parser ()-dropSpaces = do-    Value s p <- get-    let n = length $ takeWhile isSpace s-    consume n--------------------------------------------------------------------------- * Parser--parse :: ParseOptions -> Parser [Tag]-parse opts = do-    Value s p <- get-    case s of-        '<':'!':'-':'-':_ -> consume 4 >> comment opts p-        '<':'/':_         -> consume 2 >> close opts p-        '<':_             -> consume 1 >> open opts p-        []                -> return []-        '&':_             -> do-            consume 1-            s <- entity opts p-            rest <- parse opts-            return $ s ++ rest-        s:ss              -> do-            consume 1-            rest <- parse opts-            return $ tagPos opts p ++ [TagText [s]] ++ rest---- have read "<!--"-comment opts p1 = do-    ~(inner,bad) <- breakOn "-->"-    rest <- parse opts-    return $ tagPos opts p1 ++ [TagComment inner] ++-             (bad ?-> tagPosWarn opts p1 "Unexpected end when looking for \"-->\"") ++-             rest---close opts p1 = do-        name <- breakName-        dropSpaces-        ~(Value s p) <- get-        rest <- f s-        return $ tagPos opts p1 ++ [TagClose name] ++-                 (null name ?-> tagPosWarn opts p1 "Empty name in close tag") ++-                 rest-    where-        f ('>':s) = do-            consume 1-            rest <- parse opts-            return rest--        f _ = do-            ~(_,bad) <- breakOn ">"-            rest <- parse opts-            return $ tagPosWarn opts p1 "Junk in closing tag" ++-                     bad ?-> tagPosWarn opts p1 "Unexpected end when looking for \">\"" ++-                     rest----- an open tag, perhaps <? or <!-open opts p1 = do-    Value s p <- get-    prefix <- if take 1 s `elem` ["!","?"] then consume 1 >> return [head s] else return ""-    name <- liftM (prefix++) breakName-    if null name then do-        rest <- parse opts-        return $ tagPos opts p1 ++ [TagText ('<':prefix)] ++ tagPosWarn opts p1 "Expected name of tag" ++ rest-     else do-        ~(atts,shut,warns) <- attribs opts p1-        rest <- parse opts-        return $ tagPos opts p1 ++ [TagOpen name atts] ++-                 shut ?-> (tagPos opts p1 ++ [TagClose name]) ++-                 warns ++ rest----- read a list of attributes--- return (the attributes read, if the tag is self-shutting, any warnings) -attribs :: ParseOptions -> Position -> Parser ([Attribute],Bool,[Tag])-attribs opts p1 = do-    dropSpaces-    Value s p <- get-    case s of-        '/':'>':_ -> consume 2 >> return ([],True ,[])-        '>':_     -> consume 1 >> return ([],False,[])-        x:xs | x `elem` "'\"" -> do-            ~(val,warns1) <- value opts-            ~(atts,shut,warns2) <- attribs opts p1-            return (("",val):atts,shut,warns1++warns2)-        []        -> return ([],False,tagPosWarn opts p1 "Unexpected end when looking for \">\"")-        _ -> attrib opts p1----- read a single attribute--- return (the attributes read, if the tag is self-shutting, any warnings) -attrib :: ParseOptions -> Position -> Parser ([Attribute],Bool,[Tag])-attrib opts p1 = do-    name <- breakName-    if null name then do-        consume 1-        ~(atts,shut,warns) <- attribs opts p1-        return (atts,shut,tagPosWarn opts p1 "Junk character in tag" ++ warns)-     else do-        ~(Value sold p) <- get-        dropSpaces-        ~(Value s p) <- get-        ~(val,warns1) <- f sold s-        ~(atts,shut,warns2) <- attribs opts p1-        return ((name,val):atts,shut,warns1++warns2)-    where-        f sold ('=':s) = consume 1 >> dropSpaces >> value opts-        f sold s | not $ junk sold = return ([], [])-                 | otherwise = do-                      ~(Value s p) <- get-                      dropJunk-                      return ([], tagPosWarn opts p "Junk character in tag")--        junk ('/':'>':_) = False-        junk ('>':_) = False-        junk (c:cs) | not $ isSpace c = True-        junk _ = False-        -        dropJunk = do-            ~(Value s p) <- get-            when (junk s) $ consume 1 >> dropJunk----- read a single value--- return (value,warnings)-value :: ParseOptions -> Parser (String,[Tag])-value opts = do-    Value s p <- get-    case s of-        '\"':_ -> consume 1 >> f p True "\""-        '\'':_ -> consume 1 >> f p True "\'"-        _ -> f p False ">"-    where-        f p1 quote end = do-            Value s p <- get-            case s of-                '&':_ -> do-                    consume 1-                    ~(cs1,warns1) <- entityString opts p-                    ~(cs2,warns2) <- f p1 quote end-                    return (cs1++cs2,warns1++warns2)-                '/':'>':_ | not quote -> do-                    return ([],[])-                c:_ | c `elem` end || (not quote && isSpace c) -> do-                    if quote then consume 1 else return ()-                    return ([],[])-                c:_ -> do-                    consume 1-                    ~(cs,warns) <- f p1 quote end-                    return (c:cs,warns)-                [] -> return ([],tagPosWarn opts p1 "Unexpected end in attibute value")------ have seen an &, and have consumed it--- return a [Tag] to go in a tag stream-entity :: ParseOptions -> Position -> Parser [Tag]-entity opts p1 = do-    Value s p <- get-    case s of-        '#':'x':_ -> f "#x" isHexDigit -        '#':_     -> f "#"  isDigit-        _         -> f ""   isNameChar-    where-        f prefix match = do-            consume (length prefix)-            g match (reverse prefix) (fromMaybe maxBound (optMaxEntityLength opts))-        -        g match buf bound | bound < 0 = return $-            tagPos opts p1 ++ [TagText ('&':reverse buf)] ++-            tagPosWarn opts p1 "Unexpected '&' not in an entity"--        g match buf bound = do-            Value s p <- get-            case s of-                ';':_ -> do-                    consume 1-                    return $ tagPosWarnFix opts p1 $ optLookupEntity opts (reverse buf)-                x:xs | match x -> consume 1 >> g match (x:buf) (bound-1) -                _ -> g match buf (-1)-            ----- return the tag and some position information-entityString :: ParseOptions -> Position -> Parser (String,[Tag])-entityString opts p = do-    tags <- entity opts p-    let warnings = tagPosWarnFix opts p $ filter isTagWarning tags-    return (innerText tags, warnings)
Test/examples/RecordInfixSelector.hs view
@@ -1,3 +1,3 @@-data RecordWithInfixSelector = Cons { (<>) :: Int -> Int }
-
+data RecordWithInfixSelector = Cons { (<>) :: Int -> Int }+ idRecord = Cons { (<>) = id }
− Test/examples/RecordWildcards.hs
@@ -1,5 +0,0 @@-{-# LANGUAGE RecordWildCards, NamedFieldPuns #-}--data Foo = Foo {a :: Int, b :: Int}--foo Foo{b, ..} = a
Test/examples/RelaxedDo.hs view
@@ -1,13 +1,14 @@-module Main where
-
-import Control.Monad
-
-main :: IO ()
-main = do
-  when ( 2 > 1) $ do
-  putStrLn "a"
-  putStrLn "b"
-
-nestedDoBlocks = getChar >>= (\c1 -> do
-                 getChar >>= (\c2 -> do
+{-# LANGUAGE NondecreasingIndentation #-}+module Main where++import Control.Monad++main :: IO ()+main = do+  when ( 2 > 1) $ do+  putStrLn "a"+  putStrLn "b"++nestedDoBlocks = getChar >>= (\c1 -> do+                 getChar >>= (\c2 -> do                  getChar >>= (\c3 -> return [c1,c2,c3])))
Test/examples/SCCPragmas.hs view
@@ -1,3 +1,3 @@-module SCCPragmas where
-
+module SCCPragmas where+ x = {-# SCC "wibble" #-} 3
Test/examples/SingleClassAsst.hs view
@@ -1,4 +1,4 @@-module Test where
-
-foo :: (Eq a) => a -> a
+module Test where++foo :: (Eq a) => a -> a foo x = x
Test/examples/SpecializeInstance.hs view
@@ -1,4 +1,4 @@-instance Sized a => Sized (Digit a) where
-       {-# SPECIALIZE instance Sized (Digit (Elem a)) #-}
-       {-# SPECIALIZE instance Sized (Digit (Node a)) #-}
+instance Sized a => Sized (Digit a) where+       {-# SPECIALIZE instance Sized (Digit (Elem a)) #-}+       {-# SPECIALIZE instance Sized (Digit (Node a)) #-}        size xs = foldl (\ i x -> i + size x) 0 xs
+ Test/examples/SpecializePhaseControl.hs view
@@ -0,0 +1,15 @@+{-# SPECIALISE [1] x ::+        Integer -> Integer -> Integer,+        Integer -> Int -> Integer,+        Int -> Int -> Int #-}+{-# INLINABLE [1] x #-}+x :: (Num a, Integral b) => a -> b -> a+x = undefined++{-# SPECIALISE INLINE [999] y ::+        Integer -> Integer -> Integer,+        Integer -> Int -> Integer,+        Int -> Int -> Int #-}+{-# INLINABLE [1] y #-}+y :: (Num a, Integral b) => a -> b -> a+y = undefined
+ Test/examples/THTypes.hs view
@@ -0,0 +1,11 @@+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE QuasiQuotes #-}+module THTypes where++import Language.Haskell.TH++x :: DecsQ+x = [d| instance Show $(conT (mkName \"Int\")) |]++unit x = [t| $x |]
Test/examples/Testing.hs view
@@ -1,2 +1,2 @@-{-# LINE 5 "templates\GenericTemplate.hs" #-}
+{-# LINE 5 "templates\GenericTemplate.hs" #-} main = return ()
Test/examples/TupleSections.hs view
@@ -1,3 +1,3 @@-{-# LANGUAGE TupleSections #-}
-
+{-# LANGUAGE TupleSections #-}+ foo x = (1,,) x 3
+ Test/examples/TypeOperatorAsVariable.hs view
@@ -0,0 +1,5 @@+{-# LANGUAGE TypeOperators #-}++type T (~>) = ()++type Foo = ()
+ Test/examples/UnboxedSingleton.hs view
@@ -0,0 +1,3 @@+{-# LANGUAGE UnboxedTuples #-}+-- See e.g. GHC.Prim.indexArray#+foo a = (# a #)
+ Test/examples/UnboxedTuples.hs view
@@ -0,0 +1,6 @@+{-# LANGUAGE UnboxedTuples #-}++foo :: (a, b) -> (# b , a #)+foo (a, b) =+  case (# b, a #) of+    (# b, a #) -> (# , #) b a
Test/examples/UnicodeSyntax.hs view
@@ -1,12 +1,15 @@-{-# LANGUAGE UnicodeSyntax #-}
-module UnicodeSyntax where
-
-import System.Environment (getArgs)
-
-main :: IO ()
-main = do
-  as ← getArgs
-  print $ test 0
-
-test :: Int → Bool
-test x = x*5 == x+8
+{-# LANGUAGE UnicodeSyntax, ExplicitForall #-}+module UnicodeSyntax where++import System.Environment (getArgs)++main :: IO ()+main = do+  as ← getArgs+  print $ test 0++test :: Int → Bool+test x = x*5 == x+8++id1 ∷ ∀ a . a → a+id1 x = x
Test/examples/WhereBlock.hs view
@@ -1,3 +1,3 @@-hash ptr len = f len
- where f h = return h
-       f p = (p `advancePtr` 1)
+hash ptr len = f len+ where f h = return h+       f p = (p `advancePtr` 1)
− Test/examples/WithKeyword.hs
@@ -1,1 +0,0 @@-with = 1
Test/failing.txt view
@@ -1,8 +1,21 @@-GADTRecord.hs		GADT records not yet supported.
-DoRec.hs		DoRec not yet supported.
-CStyleLinePragmas.hs	Shouldn't succeed. HSE does not and will not support C-style line pragmas.
-QuasiQuoteSplice.hs	Splicing inside quasi-quotes fails
-ExtraEndBrace.hs	Should fail - but gracefully
-ArityMismatch.hs	Should fail - but give error message in the right place
-ForallInInstance.hs	Bug - needs AST change
-BadStringLineBreak.hs	Shouldn't succeed.
+GADTRecord.hs		 GADT records not yet supported.+DoRec.hs		 DoRec not yet supported.+CStyleLinePragmas.hs	 Shouldn't succeed. HSE does not and will not support C-style line pragmas.+QuasiQuoteSplice.hs	 Splicing inside quasi-quotes fails+ExtraEndBrace.hs	 Should fail - but gracefully+ArityMismatch.hs	 Should fail - but give error message in the right place+ForallInInstance.hs	 Bug - needs AST change+BadStringLineBreak.hs	 Shouldn't succeed.+NonDecreasing.hs	 Shouldn't succeed without -XNondecreasingIndentation.+THTypes.hs		 Type splices not yet supported+QQType.hs                Same issue as above+UnicodeSyntax.hs         Unicode forall symbol not working+IllDataTypeDecl.hs       Parser doesn't handle all declaration heads+ConstraintKinds.hs       ConstraintKinds in type synonyms not yet supported.+RCategory.lhs            ConstraintKinds not supported in general.+IndentedWhereBlock.hs    Bug - needs fixes to layout parsing+NegPrimWordLiteral.hs    Primitive word literals cannot be negative.+RecordPuns.hs            Qualified record puns not yet supported.+IndentedTopLevelWhere.hs Weird layout bug.+MultiWayIf.hs            Multi-way if statements not yet supported.+LambdaCase.hs            Lambda-case expressions not yet supported.
Test/printFail.txt view
@@ -1,6 +1,6 @@-HexPrec.hs		Uses hexadecimal notation to specify precedence of infix operator. We don't retain that info.
-RealGHC.lhs		Literate haskell.
-SpecializeInstance.hs	Prints SPECIALISE instead of SPECIALIZE.
-Unicode.hs		Printing is not Unicode-aware.
-UnicodeSyntax.hs	Printing is not Unicode-aware.
-QuasiQuoteOld.hs	Exact printer always uses new quasi-quote syntax.
+HexPrec.hs		Uses hexadecimal notation to specify precedence of infix operator. We don't retain that info.+RealGHC.lhs		Literate haskell.+SpecializeInstance.hs	Prints SPECIALISE instead of SPECIALIZE.+Unicode.hs		Printing is not Unicode-aware.+UnicodeSyntax.hs	Printing is not Unicode-aware.+QuasiQuoteOld.hs	Exact printer always uses new quasi-quote syntax.
dist/build/Language/Haskell/Exts/InternalParser.hs view
@@ -1,8262 +1,8365 @@-{-# OPTIONS -fglasgow-exts -cpp #-}-{-# OPTIONS_HADDOCK hide #-}--------------------------------------------------------------------------------- |--- Module      :  Language.Haskell.Exts.Annotated.Parser--- Copyright   :  (c) Niklas Broberg 2004-2009,---                Original (c) Simon Marlow, Sven Panne 1997-2000--- License     :  BSD-style (see the file LICENSE.txt)------ Maintainer  :  Niklas Broberg, d00nibro@chalmers.se--- Stability   :  stable--- Portability :  portable-------------------------------------------------------------------------------------module Language.Haskell.Exts.InternalParser (-              -- * General parsing-              ParseMode(..), defaultParseMode, ParseResult(..), fromParseResult,-              -- * Parsing of specific AST elements-              -- ** Modules-              parseModule, parseModuleWithMode, parseModuleWithComments,-              -- ** Expressions-              parseExp, parseExpWithMode, parseExpWithComments,-              -- ** Statements-              parseStmt, parseStmtWithMode, parseStmtWithComments,-              -- ** Patterns-              parsePat, parsePatWithMode, parsePatWithComments,-              -- ** Declarations-              parseDecl, parseDeclWithMode, parseDeclWithComments,-              -- ** Types-              parseType, parseTypeWithMode, parseTypeWithComments,-              -- ** Multiple modules in one file-              parseModules, parseModulesWithMode, parseModulesWithComments,-              -- ** Option pragmas-              getTopPragmas-              ) where-import Language.Haskell.Exts.Annotated.Syntax hiding ( Type(..), Exp(..), Asst(..), XAttr(..), FieldUpdate(..) )-import Language.Haskell.Exts.Annotated.Syntax ( Type, Exp, Asst )-import Language.Haskell.Exts.ParseMonad-import Language.Haskell.Exts.InternalLexer-import Language.Haskell.Exts.ParseUtils-import Language.Haskell.Exts.Annotated.Fixity-import Language.Haskell.Exts.SrcLoc-import Language.Haskell.Exts.Comments ( Comment )-import Language.Haskell.Exts.Extension--import Control.Monad ( liftM, (<=<) )-#if __GLASGOW_HASKELL__ >= 503-import Data.Array-#else-import Array-#endif-#if __GLASGOW_HASKELL__ >= 503-import GHC.Exts-#else-import GlaExts-#endif---- parser produced by Happy Version 1.17--newtype HappyAbsSyn  = HappyAbsSyn HappyAny-#if __GLASGOW_HASKELL__ >= 607-type HappyAny = GHC.Exts.Any-#else-type HappyAny = forall a . a-#endif-happyIn11 :: ([Module L]) -> (HappyAbsSyn )-happyIn11 x = unsafeCoerce# x-{-# INLINE happyIn11 #-}-happyOut11 :: (HappyAbsSyn ) -> ([Module L])-happyOut11 x = unsafeCoerce# x-{-# INLINE happyOut11 #-}-happyIn12 :: ([[ModulePragma L] -> [S] -> L -> Module L]) -> (HappyAbsSyn )-happyIn12 x = unsafeCoerce# x-{-# INLINE happyIn12 #-}-happyOut12 :: (HappyAbsSyn ) -> ([[ModulePragma L] -> [S] -> L -> Module L])-happyOut12 x = unsafeCoerce# x-{-# INLINE happyOut12 #-}-happyIn13 :: (Module L) -> (HappyAbsSyn )-happyIn13 x = unsafeCoerce# x-{-# INLINE happyIn13 #-}-happyOut13 :: (HappyAbsSyn ) -> (Module L)-happyOut13 x = unsafeCoerce# x-{-# INLINE happyOut13 #-}-happyIn14 :: (PExp L) -> (HappyAbsSyn )-happyIn14 x = unsafeCoerce# x-{-# INLINE happyIn14 #-}-happyOut14 :: (HappyAbsSyn ) -> (PExp L)-happyOut14 x = unsafeCoerce# x-{-# INLINE happyOut14 #-}-happyIn15 :: (([ModulePragma L],[S],L)) -> (HappyAbsSyn )-happyIn15 x = unsafeCoerce# x-{-# INLINE happyIn15 #-}-happyOut15 :: (HappyAbsSyn ) -> (([ModulePragma L],[S],L))-happyOut15 x = unsafeCoerce# x-{-# INLINE happyOut15 #-}-happyIn16 :: (([ModulePragma L],[S],Maybe L)) -> (HappyAbsSyn )-happyIn16 x = unsafeCoerce# x-{-# INLINE happyIn16 #-}-happyOut16 :: (HappyAbsSyn ) -> (([ModulePragma L],[S],Maybe L))-happyOut16 x = unsafeCoerce# x-{-# INLINE happyOut16 #-}-happyIn17 :: (ModulePragma L) -> (HappyAbsSyn )-happyIn17 x = unsafeCoerce# x-{-# INLINE happyIn17 #-}-happyOut17 :: (HappyAbsSyn ) -> (ModulePragma L)-happyOut17 x = unsafeCoerce# x-{-# INLINE happyOut17 #-}-happyIn18 :: (([Name L],[S])) -> (HappyAbsSyn )-happyIn18 x = unsafeCoerce# x-{-# INLINE happyIn18 #-}-happyOut18 :: (HappyAbsSyn ) -> (([Name L],[S]))-happyOut18 x = unsafeCoerce# x-{-# INLINE happyOut18 #-}-happyIn19 :: ([ModulePragma L] -> [S] -> L -> Module L) -> (HappyAbsSyn )-happyIn19 x = unsafeCoerce# x-{-# INLINE happyIn19 #-}-happyOut19 :: (HappyAbsSyn ) -> ([ModulePragma L] -> [S] -> L -> Module L)-happyOut19 x = unsafeCoerce# x-{-# INLINE happyOut19 #-}-happyIn20 :: (Maybe (ModuleHead L)) -> (HappyAbsSyn )-happyIn20 x = unsafeCoerce# x-{-# INLINE happyIn20 #-}-happyOut20 :: (HappyAbsSyn ) -> (Maybe (ModuleHead L))-happyOut20 x = unsafeCoerce# x-{-# INLINE happyOut20 #-}-happyIn21 :: (Maybe (WarningText L)) -> (HappyAbsSyn )-happyIn21 x = unsafeCoerce# x-{-# INLINE happyIn21 #-}-happyOut21 :: (HappyAbsSyn ) -> (Maybe (WarningText L))-happyOut21 x = unsafeCoerce# x-{-# INLINE happyOut21 #-}-happyIn22 :: (([ImportDecl L],[Decl L],[S],L)) -> (HappyAbsSyn )-happyIn22 x = unsafeCoerce# x-{-# INLINE happyIn22 #-}-happyOut22 :: (HappyAbsSyn ) -> (([ImportDecl L],[Decl L],[S],L))-happyOut22 x = unsafeCoerce# x-{-# INLINE happyOut22 #-}-happyIn23 :: (([ImportDecl L],[Decl L],[S])) -> (HappyAbsSyn )-happyIn23 x = unsafeCoerce# x-{-# INLINE happyIn23 #-}-happyOut23 :: (HappyAbsSyn ) -> (([ImportDecl L],[Decl L],[S]))-happyOut23 x = unsafeCoerce# x-{-# INLINE happyOut23 #-}-happyIn24 :: ([S]) -> (HappyAbsSyn )-happyIn24 x = unsafeCoerce# x-{-# INLINE happyIn24 #-}-happyOut24 :: (HappyAbsSyn ) -> ([S])-happyOut24 x = unsafeCoerce# x-{-# INLINE happyOut24 #-}-happyIn25 :: ([S]) -> (HappyAbsSyn )-happyIn25 x = unsafeCoerce# x-{-# INLINE happyIn25 #-}-happyOut25 :: (HappyAbsSyn ) -> ([S])-happyOut25 x = unsafeCoerce# x-{-# INLINE happyOut25 #-}-happyIn26 :: (Maybe (ExportSpecList L)) -> (HappyAbsSyn )-happyIn26 x = unsafeCoerce# x-{-# INLINE happyIn26 #-}-happyOut26 :: (HappyAbsSyn ) -> (Maybe (ExportSpecList L))-happyOut26 x = unsafeCoerce# x-{-# INLINE happyOut26 #-}-happyIn27 :: (ExportSpecList L) -> (HappyAbsSyn )-happyIn27 x = unsafeCoerce# x-{-# INLINE happyIn27 #-}-happyOut27 :: (HappyAbsSyn ) -> (ExportSpecList L)-happyOut27 x = unsafeCoerce# x-{-# INLINE happyOut27 #-}-happyIn28 :: ([S]) -> (HappyAbsSyn )-happyIn28 x = unsafeCoerce# x-{-# INLINE happyIn28 #-}-happyOut28 :: (HappyAbsSyn ) -> ([S])-happyOut28 x = unsafeCoerce# x-{-# INLINE happyOut28 #-}-happyIn29 :: (([ExportSpec L],[S])) -> (HappyAbsSyn )-happyIn29 x = unsafeCoerce# x-{-# INLINE happyIn29 #-}-happyOut29 :: (HappyAbsSyn ) -> (([ExportSpec L],[S]))-happyOut29 x = unsafeCoerce# x-{-# INLINE happyOut29 #-}-happyIn30 :: (ExportSpec L) -> (HappyAbsSyn )-happyIn30 x = unsafeCoerce# x-{-# INLINE happyIn30 #-}-happyOut30 :: (HappyAbsSyn ) -> (ExportSpec L)-happyOut30 x = unsafeCoerce# x-{-# INLINE happyOut30 #-}-happyIn31 :: (([ImportDecl L],[S])) -> (HappyAbsSyn )-happyIn31 x = unsafeCoerce# x-{-# INLINE happyIn31 #-}-happyOut31 :: (HappyAbsSyn ) -> (([ImportDecl L],[S]))-happyOut31 x = unsafeCoerce# x-{-# INLINE happyOut31 #-}-happyIn32 :: (ImportDecl L) -> (HappyAbsSyn )-happyIn32 x = unsafeCoerce# x-{-# INLINE happyIn32 #-}-happyOut32 :: (HappyAbsSyn ) -> (ImportDecl L)-happyOut32 x = unsafeCoerce# x-{-# INLINE happyOut32 #-}-happyIn33 :: ((Bool,[S])) -> (HappyAbsSyn )-happyIn33 x = unsafeCoerce# x-{-# INLINE happyIn33 #-}-happyOut33 :: (HappyAbsSyn ) -> ((Bool,[S]))-happyOut33 x = unsafeCoerce# x-{-# INLINE happyOut33 #-}-happyIn34 :: ((Bool,[S])) -> (HappyAbsSyn )-happyIn34 x = unsafeCoerce# x-{-# INLINE happyIn34 #-}-happyOut34 :: (HappyAbsSyn ) -> ((Bool,[S]))-happyOut34 x = unsafeCoerce# x-{-# INLINE happyOut34 #-}-happyIn35 :: ((Maybe String,[S])) -> (HappyAbsSyn )-happyIn35 x = unsafeCoerce# x-{-# INLINE happyIn35 #-}-happyOut35 :: (HappyAbsSyn ) -> ((Maybe String,[S]))-happyOut35 x = unsafeCoerce# x-{-# INLINE happyOut35 #-}-happyIn36 :: ((Maybe (ModuleName L),[S],Maybe L)) -> (HappyAbsSyn )-happyIn36 x = unsafeCoerce# x-{-# INLINE happyIn36 #-}-happyOut36 :: (HappyAbsSyn ) -> ((Maybe (ModuleName L),[S],Maybe L))-happyOut36 x = unsafeCoerce# x-{-# INLINE happyOut36 #-}-happyIn37 :: (Maybe (ImportSpecList L)) -> (HappyAbsSyn )-happyIn37 x = unsafeCoerce# x-{-# INLINE happyIn37 #-}-happyOut37 :: (HappyAbsSyn ) -> (Maybe (ImportSpecList L))-happyOut37 x = unsafeCoerce# x-{-# INLINE happyOut37 #-}-happyIn38 :: (ImportSpecList L) -> (HappyAbsSyn )-happyIn38 x = unsafeCoerce# x-{-# INLINE happyIn38 #-}-happyOut38 :: (HappyAbsSyn ) -> (ImportSpecList L)-happyOut38 x = unsafeCoerce# x-{-# INLINE happyOut38 #-}-happyIn39 :: ((Bool, Maybe L,[S])) -> (HappyAbsSyn )-happyIn39 x = unsafeCoerce# x-{-# INLINE happyIn39 #-}-happyOut39 :: (HappyAbsSyn ) -> ((Bool, Maybe L,[S]))-happyOut39 x = unsafeCoerce# x-{-# INLINE happyOut39 #-}-happyIn40 :: (([ImportSpec L],[S])) -> (HappyAbsSyn )-happyIn40 x = unsafeCoerce# x-{-# INLINE happyIn40 #-}-happyOut40 :: (HappyAbsSyn ) -> (([ImportSpec L],[S]))-happyOut40 x = unsafeCoerce# x-{-# INLINE happyOut40 #-}-happyIn41 :: (ImportSpec L) -> (HappyAbsSyn )-happyIn41 x = unsafeCoerce# x-{-# INLINE happyIn41 #-}-happyOut41 :: (HappyAbsSyn ) -> (ImportSpec L)-happyOut41 x = unsafeCoerce# x-{-# INLINE happyOut41 #-}-happyIn42 :: (([CName L],[S])) -> (HappyAbsSyn )-happyIn42 x = unsafeCoerce# x-{-# INLINE happyIn42 #-}-happyOut42 :: (HappyAbsSyn ) -> (([CName L],[S]))-happyOut42 x = unsafeCoerce# x-{-# INLINE happyOut42 #-}-happyIn43 :: (CName L) -> (HappyAbsSyn )-happyIn43 x = unsafeCoerce# x-{-# INLINE happyIn43 #-}-happyOut43 :: (HappyAbsSyn ) -> (CName L)-happyOut43 x = unsafeCoerce# x-{-# INLINE happyOut43 #-}-happyIn44 :: (Decl L) -> (HappyAbsSyn )-happyIn44 x = unsafeCoerce# x-{-# INLINE happyIn44 #-}-happyOut44 :: (HappyAbsSyn ) -> (Decl L)-happyOut44 x = unsafeCoerce# x-{-# INLINE happyOut44 #-}-happyIn45 :: ((Maybe Int, [S])) -> (HappyAbsSyn )-happyIn45 x = unsafeCoerce# x-{-# INLINE happyIn45 #-}-happyOut45 :: (HappyAbsSyn ) -> ((Maybe Int, [S]))-happyOut45 x = unsafeCoerce# x-{-# INLINE happyOut45 #-}-happyIn46 :: (Assoc L) -> (HappyAbsSyn )-happyIn46 x = unsafeCoerce# x-{-# INLINE happyIn46 #-}-happyOut46 :: (HappyAbsSyn ) -> (Assoc L)-happyOut46 x = unsafeCoerce# x-{-# INLINE happyOut46 #-}-happyIn47 :: (([Op L],[S],L)) -> (HappyAbsSyn )-happyIn47 x = unsafeCoerce# x-{-# INLINE happyIn47 #-}-happyOut47 :: (HappyAbsSyn ) -> (([Op L],[S],L))-happyOut47 x = unsafeCoerce# x-{-# INLINE happyOut47 #-}-happyIn48 :: (([Decl L],[S])) -> (HappyAbsSyn )-happyIn48 x = unsafeCoerce# x-{-# INLINE happyIn48 #-}-happyOut48 :: (HappyAbsSyn ) -> (([Decl L],[S]))-happyOut48 x = unsafeCoerce# x-{-# INLINE happyOut48 #-}-happyIn49 :: (([Decl L],[S])) -> (HappyAbsSyn )-happyIn49 x = unsafeCoerce# x-{-# INLINE happyIn49 #-}-happyOut49 :: (HappyAbsSyn ) -> (([Decl L],[S]))-happyOut49 x = unsafeCoerce# x-{-# INLINE happyOut49 #-}-happyIn50 :: (Decl L) -> (HappyAbsSyn )-happyIn50 x = unsafeCoerce# x-{-# INLINE happyIn50 #-}-happyOut50 :: (HappyAbsSyn ) -> (Decl L)-happyOut50 x = unsafeCoerce# x-{-# INLINE happyOut50 #-}-happyIn51 :: (DataOrNew L) -> (HappyAbsSyn )-happyIn51 x = unsafeCoerce# x-{-# INLINE happyIn51 #-}-happyOut51 :: (HappyAbsSyn ) -> (DataOrNew L)-happyOut51 x = unsafeCoerce# x-{-# INLINE happyOut51 #-}-happyIn52 :: (([Type L],[S])) -> (HappyAbsSyn )-happyIn52 x = unsafeCoerce# x-{-# INLINE happyIn52 #-}-happyOut52 :: (HappyAbsSyn ) -> (([Type L],[S]))-happyOut52 x = unsafeCoerce# x-{-# INLINE happyOut52 #-}-happyIn53 :: (([Decl L],[S])) -> (HappyAbsSyn )-happyIn53 x = unsafeCoerce# x-{-# INLINE happyIn53 #-}-happyOut53 :: (HappyAbsSyn ) -> (([Decl L],[S]))-happyOut53 x = unsafeCoerce# x-{-# INLINE happyOut53 #-}-happyIn54 :: (([Decl L],[S])) -> (HappyAbsSyn )-happyIn54 x = unsafeCoerce# x-{-# INLINE happyIn54 #-}-happyOut54 :: (HappyAbsSyn ) -> (([Decl L],[S]))-happyOut54 x = unsafeCoerce# x-{-# INLINE happyOut54 #-}-happyIn55 :: (Decl L) -> (HappyAbsSyn )-happyIn55 x = unsafeCoerce# x-{-# INLINE happyIn55 #-}-happyOut55 :: (HappyAbsSyn ) -> (Decl L)-happyOut55 x = unsafeCoerce# x-{-# INLINE happyOut55 #-}-happyIn56 :: (Binds L) -> (HappyAbsSyn )-happyIn56 x = unsafeCoerce# x-{-# INLINE happyIn56 #-}-happyOut56 :: (HappyAbsSyn ) -> (Binds L)-happyOut56 x = unsafeCoerce# x-{-# INLINE happyOut56 #-}-happyIn57 :: (Decl L) -> (HappyAbsSyn )-happyIn57 x = unsafeCoerce# x-{-# INLINE happyIn57 #-}-happyOut57 :: (HappyAbsSyn ) -> (Decl L)-happyOut57 x = unsafeCoerce# x-{-# INLINE happyOut57 #-}-happyIn58 :: (Decl L) -> (HappyAbsSyn )-happyIn58 x = unsafeCoerce# x-{-# INLINE happyIn58 #-}-happyOut58 :: (HappyAbsSyn ) -> (Decl L)-happyOut58 x = unsafeCoerce# x-{-# INLINE happyOut58 #-}-happyIn59 :: (([Type L],[S])) -> (HappyAbsSyn )-happyIn59 x = unsafeCoerce# x-{-# INLINE happyIn59 #-}-happyOut59 :: (HappyAbsSyn ) -> (([Type L],[S]))-happyOut59 x = unsafeCoerce# x-{-# INLINE happyOut59 #-}-happyIn60 :: (Type L) -> (HappyAbsSyn )-happyIn60 x = unsafeCoerce# x-{-# INLINE happyIn60 #-}-happyOut60 :: (HappyAbsSyn ) -> (Type L)-happyOut60 x = unsafeCoerce# x-{-# INLINE happyOut60 #-}-happyIn61 :: (Binds L) -> (HappyAbsSyn )-happyIn61 x = unsafeCoerce# x-{-# INLINE happyIn61 #-}-happyOut61 :: (HappyAbsSyn ) -> (Binds L)-happyOut61 x = unsafeCoerce# x-{-# INLINE happyOut61 #-}-happyIn62 :: (([Name L],[S],L)) -> (HappyAbsSyn )-happyIn62 x = unsafeCoerce# x-{-# INLINE happyIn62 #-}-happyOut62 :: (HappyAbsSyn ) -> (([Name L],[S],L))-happyOut62 x = unsafeCoerce# x-{-# INLINE happyOut62 #-}-happyIn63 :: (CallConv L) -> (HappyAbsSyn )-happyIn63 x = unsafeCoerce# x-{-# INLINE happyIn63 #-}-happyOut63 :: (HappyAbsSyn ) -> (CallConv L)-happyOut63 x = unsafeCoerce# x-{-# INLINE happyOut63 #-}-happyIn64 :: (Maybe (Safety L)) -> (HappyAbsSyn )-happyIn64 x = unsafeCoerce# x-{-# INLINE happyIn64 #-}-happyOut64 :: (HappyAbsSyn ) -> (Maybe (Safety L))-happyOut64 x = unsafeCoerce# x-{-# INLINE happyOut64 #-}-happyIn65 :: ((Maybe String, Name L, Type L, [S])) -> (HappyAbsSyn )-happyIn65 x = unsafeCoerce# x-{-# INLINE happyIn65 #-}-happyOut65 :: (HappyAbsSyn ) -> ((Maybe String, Name L, Type L, [S]))-happyOut65 x = unsafeCoerce# x-{-# INLINE happyOut65 #-}-happyIn66 :: ([Rule L]) -> (HappyAbsSyn )-happyIn66 x = unsafeCoerce# x-{-# INLINE happyIn66 #-}-happyOut66 :: (HappyAbsSyn ) -> ([Rule L])-happyOut66 x = unsafeCoerce# x-{-# INLINE happyOut66 #-}-happyIn67 :: (Rule L) -> (HappyAbsSyn )-happyIn67 x = unsafeCoerce# x-{-# INLINE happyIn67 #-}-happyOut67 :: (HappyAbsSyn ) -> (Rule L)-happyOut67 x = unsafeCoerce# x-{-# INLINE happyOut67 #-}-happyIn68 :: (Maybe (Activation L)) -> (HappyAbsSyn )-happyIn68 x = unsafeCoerce# x-{-# INLINE happyIn68 #-}-happyOut68 :: (HappyAbsSyn ) -> (Maybe (Activation L))-happyOut68 x = unsafeCoerce# x-{-# INLINE happyOut68 #-}-happyIn69 :: ((Maybe [RuleVar L],[S])) -> (HappyAbsSyn )-happyIn69 x = unsafeCoerce# x-{-# INLINE happyIn69 #-}-happyOut69 :: (HappyAbsSyn ) -> ((Maybe [RuleVar L],[S]))-happyOut69 x = unsafeCoerce# x-{-# INLINE happyOut69 #-}-happyIn70 :: ([RuleVar L]) -> (HappyAbsSyn )-happyIn70 x = unsafeCoerce# x-{-# INLINE happyIn70 #-}-happyOut70 :: (HappyAbsSyn ) -> ([RuleVar L])-happyOut70 x = unsafeCoerce# x-{-# INLINE happyOut70 #-}-happyIn71 :: (RuleVar L) -> (HappyAbsSyn )-happyIn71 x = unsafeCoerce# x-{-# INLINE happyIn71 #-}-happyOut71 :: (HappyAbsSyn ) -> (RuleVar L)-happyOut71 x = unsafeCoerce# x-{-# INLINE happyOut71 #-}-happyIn72 :: (([([Name L],String)],[S])) -> (HappyAbsSyn )-happyIn72 x = unsafeCoerce# x-{-# INLINE happyIn72 #-}-happyOut72 :: (HappyAbsSyn ) -> (([([Name L],String)],[S]))-happyOut72 x = unsafeCoerce# x-{-# INLINE happyOut72 #-}-happyIn73 :: ((([Name L], String),[S])) -> (HappyAbsSyn )-happyIn73 x = unsafeCoerce# x-{-# INLINE happyIn73 #-}-happyOut73 :: (HappyAbsSyn ) -> ((([Name L], String),[S]))-happyOut73 x = unsafeCoerce# x-{-# INLINE happyOut73 #-}-happyIn74 :: (([Name L],[S])) -> (HappyAbsSyn )-happyIn74 x = unsafeCoerce# x-{-# INLINE happyIn74 #-}-happyOut74 :: (HappyAbsSyn ) -> (([Name L],[S]))-happyOut74 x = unsafeCoerce# x-{-# INLINE happyOut74 #-}-happyIn75 :: (Name L) -> (HappyAbsSyn )-happyIn75 x = unsafeCoerce# x-{-# INLINE happyIn75 #-}-happyOut75 :: (HappyAbsSyn ) -> (Name L)-happyOut75 x = unsafeCoerce# x-{-# INLINE happyOut75 #-}-happyIn76 :: (Annotation L) -> (HappyAbsSyn )-happyIn76 x = unsafeCoerce# x-{-# INLINE happyIn76 #-}-happyOut76 :: (HappyAbsSyn ) -> (Annotation L)-happyOut76 x = unsafeCoerce# x-{-# INLINE happyOut76 #-}-happyIn77 :: (Type L) -> (HappyAbsSyn )-happyIn77 x = unsafeCoerce# x-{-# INLINE happyIn77 #-}-happyOut77 :: (HappyAbsSyn ) -> (Type L)-happyOut77 x = unsafeCoerce# x-{-# INLINE happyOut77 #-}-happyIn78 :: (PType L) -> (HappyAbsSyn )-happyIn78 x = unsafeCoerce# x-{-# INLINE happyIn78 #-}-happyOut78 :: (HappyAbsSyn ) -> (PType L)-happyOut78 x = unsafeCoerce# x-{-# INLINE happyOut78 #-}-happyIn79 :: (Type L) -> (HappyAbsSyn )-happyIn79 x = unsafeCoerce# x-{-# INLINE happyIn79 #-}-happyOut79 :: (HappyAbsSyn ) -> (Type L)-happyOut79 x = unsafeCoerce# x-{-# INLINE happyOut79 #-}-happyIn80 :: (PType L) -> (HappyAbsSyn )-happyIn80 x = unsafeCoerce# x-{-# INLINE happyIn80 #-}-happyOut80 :: (HappyAbsSyn ) -> (PType L)-happyOut80 x = unsafeCoerce# x-{-# INLINE happyOut80 #-}-happyIn81 :: (Type L) -> (HappyAbsSyn )-happyIn81 x = unsafeCoerce# x-{-# INLINE happyIn81 #-}-happyOut81 :: (HappyAbsSyn ) -> (Type L)-happyOut81 x = unsafeCoerce# x-{-# INLINE happyOut81 #-}-happyIn82 :: (PType L) -> (HappyAbsSyn )-happyIn82 x = unsafeCoerce# x-{-# INLINE happyIn82 #-}-happyOut82 :: (HappyAbsSyn ) -> (PType L)-happyOut82 x = unsafeCoerce# x-{-# INLINE happyOut82 #-}-happyIn83 :: (Type L) -> (HappyAbsSyn )-happyIn83 x = unsafeCoerce# x-{-# INLINE happyIn83 #-}-happyOut83 :: (HappyAbsSyn ) -> (Type L)-happyOut83 x = unsafeCoerce# x-{-# INLINE happyOut83 #-}-happyIn84 :: (PType L) -> (HappyAbsSyn )-happyIn84 x = unsafeCoerce# x-{-# INLINE happyIn84 #-}-happyOut84 :: (HappyAbsSyn ) -> (PType L)-happyOut84 x = unsafeCoerce# x-{-# INLINE happyOut84 #-}-happyIn85 :: (QName L) -> (HappyAbsSyn )-happyIn85 x = unsafeCoerce# x-{-# INLINE happyIn85 #-}-happyOut85 :: (HappyAbsSyn ) -> (QName L)-happyOut85 x = unsafeCoerce# x-{-# INLINE happyOut85 #-}-happyIn86 :: (QName L) -> (HappyAbsSyn )-happyIn86 x = unsafeCoerce# x-{-# INLINE happyIn86 #-}-happyOut86 :: (HappyAbsSyn ) -> (QName L)-happyOut86 x = unsafeCoerce# x-{-# INLINE happyOut86 #-}-happyIn87 :: (QName L) -> (HappyAbsSyn )-happyIn87 x = unsafeCoerce# x-{-# INLINE happyIn87 #-}-happyOut87 :: (HappyAbsSyn ) -> (QName L)-happyOut87 x = unsafeCoerce# x-{-# INLINE happyOut87 #-}-happyIn88 :: (Type L) -> (HappyAbsSyn )-happyIn88 x = unsafeCoerce# x-{-# INLINE happyIn88 #-}-happyOut88 :: (HappyAbsSyn ) -> (Type L)-happyOut88 x = unsafeCoerce# x-{-# INLINE happyOut88 #-}-happyIn89 :: (PType L) -> (HappyAbsSyn )-happyIn89 x = unsafeCoerce# x-{-# INLINE happyIn89 #-}-happyOut89 :: (HappyAbsSyn ) -> (PType L)-happyOut89 x = unsafeCoerce# x-{-# INLINE happyOut89 #-}-happyIn90 :: (PContext L) -> (HappyAbsSyn )-happyIn90 x = unsafeCoerce# x-{-# INLINE happyIn90 #-}-happyOut90 :: (HappyAbsSyn ) -> (PContext L)-happyOut90 x = unsafeCoerce# x-{-# INLINE happyOut90 #-}-happyIn91 :: (([PType L],[S])) -> (HappyAbsSyn )-happyIn91 x = unsafeCoerce# x-{-# INLINE happyIn91 #-}-happyOut91 :: (HappyAbsSyn ) -> (([PType L],[S]))-happyOut91 x = unsafeCoerce# x-{-# INLINE happyOut91 #-}-happyIn92 :: (([PType L],[S])) -> (HappyAbsSyn )-happyIn92 x = unsafeCoerce# x-{-# INLINE happyIn92 #-}-happyOut92 :: (HappyAbsSyn ) -> (([PType L],[S]))-happyOut92 x = unsafeCoerce# x-{-# INLINE happyOut92 #-}-happyIn93 :: (([TyVarBind L],Maybe L)) -> (HappyAbsSyn )-happyIn93 x = unsafeCoerce# x-{-# INLINE happyIn93 #-}-happyOut93 :: (HappyAbsSyn ) -> (([TyVarBind L],Maybe L))-happyOut93 x = unsafeCoerce# x-{-# INLINE happyOut93 #-}-happyIn94 :: (TyVarBind L) -> (HappyAbsSyn )-happyIn94 x = unsafeCoerce# x-{-# INLINE happyIn94 #-}-happyOut94 :: (HappyAbsSyn ) -> (TyVarBind L)-happyOut94 x = unsafeCoerce# x-{-# INLINE happyOut94 #-}-happyIn95 :: (([Name L],Maybe L)) -> (HappyAbsSyn )-happyIn95 x = unsafeCoerce# x-{-# INLINE happyIn95 #-}-happyOut95 :: (HappyAbsSyn ) -> (([Name L],Maybe L))-happyOut95 x = unsafeCoerce# x-{-# INLINE happyOut95 #-}-happyIn96 :: (([Name L],L)) -> (HappyAbsSyn )-happyIn96 x = unsafeCoerce# x-{-# INLINE happyIn96 #-}-happyOut96 :: (HappyAbsSyn ) -> (([Name L],L))-happyOut96 x = unsafeCoerce# x-{-# INLINE happyOut96 #-}-happyIn97 :: (([FunDep L],[S],Maybe L)) -> (HappyAbsSyn )-happyIn97 x = unsafeCoerce# x-{-# INLINE happyIn97 #-}-happyOut97 :: (HappyAbsSyn ) -> (([FunDep L],[S],Maybe L))-happyOut97 x = unsafeCoerce# x-{-# INLINE happyOut97 #-}-happyIn98 :: (([FunDep L],[S],L)) -> (HappyAbsSyn )-happyIn98 x = unsafeCoerce# x-{-# INLINE happyIn98 #-}-happyOut98 :: (HappyAbsSyn ) -> (([FunDep L],[S],L))-happyOut98 x = unsafeCoerce# x-{-# INLINE happyOut98 #-}-happyIn99 :: (FunDep L) -> (HappyAbsSyn )-happyIn99 x = unsafeCoerce# x-{-# INLINE happyIn99 #-}-happyOut99 :: (HappyAbsSyn ) -> (FunDep L)-happyOut99 x = unsafeCoerce# x-{-# INLINE happyOut99 #-}-happyIn100 :: (([GadtDecl L],[S],Maybe L)) -> (HappyAbsSyn )-happyIn100 x = unsafeCoerce# x-{-# INLINE happyIn100 #-}-happyOut100 :: (HappyAbsSyn ) -> (([GadtDecl L],[S],Maybe L))-happyOut100 x = unsafeCoerce# x-{-# INLINE happyOut100 #-}-happyIn101 :: (([GadtDecl L],[S])) -> (HappyAbsSyn )-happyIn101 x = unsafeCoerce# x-{-# INLINE happyIn101 #-}-happyOut101 :: (HappyAbsSyn ) -> (([GadtDecl L],[S]))-happyOut101 x = unsafeCoerce# x-{-# INLINE happyOut101 #-}-happyIn102 :: (([GadtDecl L],[S])) -> (HappyAbsSyn )-happyIn102 x = unsafeCoerce# x-{-# INLINE happyIn102 #-}-happyOut102 :: (HappyAbsSyn ) -> (([GadtDecl L],[S]))-happyOut102 x = unsafeCoerce# x-{-# INLINE happyOut102 #-}-happyIn103 :: (GadtDecl L) -> (HappyAbsSyn )-happyIn103 x = unsafeCoerce# x-{-# INLINE happyIn103 #-}-happyOut103 :: (HappyAbsSyn ) -> (GadtDecl L)-happyOut103 x = unsafeCoerce# x-{-# INLINE happyOut103 #-}-happyIn104 :: (([QualConDecl L],[S],Maybe L)) -> (HappyAbsSyn )-happyIn104 x = unsafeCoerce# x-{-# INLINE happyIn104 #-}-happyOut104 :: (HappyAbsSyn ) -> (([QualConDecl L],[S],Maybe L))-happyOut104 x = unsafeCoerce# x-{-# INLINE happyOut104 #-}-happyIn105 :: (([QualConDecl L],[S],L)) -> (HappyAbsSyn )-happyIn105 x = unsafeCoerce# x-{-# INLINE happyIn105 #-}-happyOut105 :: (HappyAbsSyn ) -> (([QualConDecl L],[S],L))-happyOut105 x = unsafeCoerce# x-{-# INLINE happyOut105 #-}-happyIn106 :: (QualConDecl L) -> (HappyAbsSyn )-happyIn106 x = unsafeCoerce# x-{-# INLINE happyIn106 #-}-happyOut106 :: (HappyAbsSyn ) -> (QualConDecl L)-happyOut106 x = unsafeCoerce# x-{-# INLINE happyOut106 #-}-happyIn107 :: ((Maybe [TyVarBind L], [S], Maybe L)) -> (HappyAbsSyn )-happyIn107 x = unsafeCoerce# x-{-# INLINE happyIn107 #-}-happyOut107 :: (HappyAbsSyn ) -> ((Maybe [TyVarBind L], [S], Maybe L))-happyOut107 x = unsafeCoerce# x-{-# INLINE happyOut107 #-}-happyIn108 :: (ConDecl L) -> (HappyAbsSyn )-happyIn108 x = unsafeCoerce# x-{-# INLINE happyIn108 #-}-happyOut108 :: (HappyAbsSyn ) -> (ConDecl L)-happyOut108 x = unsafeCoerce# x-{-# INLINE happyOut108 #-}-happyIn109 :: ((Name L, [BangType L], L)) -> (HappyAbsSyn )-happyIn109 x = unsafeCoerce# x-{-# INLINE happyIn109 #-}-happyOut109 :: (HappyAbsSyn ) -> ((Name L, [BangType L], L))-happyOut109 x = unsafeCoerce# x-{-# INLINE happyOut109 #-}-happyIn110 :: ((Name L, [BangType L],L)) -> (HappyAbsSyn )-happyIn110 x = unsafeCoerce# x-{-# INLINE happyIn110 #-}-happyOut110 :: (HappyAbsSyn ) -> ((Name L, [BangType L],L))-happyOut110 x = unsafeCoerce# x-{-# INLINE happyOut110 #-}-happyIn111 :: (BangType L) -> (HappyAbsSyn )-happyIn111 x = unsafeCoerce# x-{-# INLINE happyIn111 #-}-happyOut111 :: (HappyAbsSyn ) -> (BangType L)-happyOut111 x = unsafeCoerce# x-{-# INLINE happyOut111 #-}-happyIn112 :: (BangType L) -> (HappyAbsSyn )-happyIn112 x = unsafeCoerce# x-{-# INLINE happyIn112 #-}-happyOut112 :: (HappyAbsSyn ) -> (BangType L)-happyOut112 x = unsafeCoerce# x-{-# INLINE happyOut112 #-}-happyIn113 :: (([FieldDecl L],[S])) -> (HappyAbsSyn )-happyIn113 x = unsafeCoerce# x-{-# INLINE happyIn113 #-}-happyOut113 :: (HappyAbsSyn ) -> (([FieldDecl L],[S]))-happyOut113 x = unsafeCoerce# x-{-# INLINE happyOut113 #-}-happyIn114 :: (FieldDecl L) -> (HappyAbsSyn )-happyIn114 x = unsafeCoerce# x-{-# INLINE happyIn114 #-}-happyOut114 :: (HappyAbsSyn ) -> (FieldDecl L)-happyOut114 x = unsafeCoerce# x-{-# INLINE happyOut114 #-}-happyIn115 :: (BangType L) -> (HappyAbsSyn )-happyIn115 x = unsafeCoerce# x-{-# INLINE happyIn115 #-}-happyOut115 :: (HappyAbsSyn ) -> (BangType L)-happyOut115 x = unsafeCoerce# x-{-# INLINE happyOut115 #-}-happyIn116 :: (Maybe (Deriving L)) -> (HappyAbsSyn )-happyIn116 x = unsafeCoerce# x-{-# INLINE happyIn116 #-}-happyOut116 :: (HappyAbsSyn ) -> (Maybe (Deriving L))-happyOut116 x = unsafeCoerce# x-{-# INLINE happyOut116 #-}-happyIn117 :: (([InstHead L],[S])) -> (HappyAbsSyn )-happyIn117 x = unsafeCoerce# x-{-# INLINE happyIn117 #-}-happyOut117 :: (HappyAbsSyn ) -> (([InstHead L],[S]))-happyOut117 x = unsafeCoerce# x-{-# INLINE happyOut117 #-}-happyIn118 :: (QName L) -> (HappyAbsSyn )-happyIn118 x = unsafeCoerce# x-{-# INLINE happyIn118 #-}-happyOut118 :: (HappyAbsSyn ) -> (QName L)-happyOut118 x = unsafeCoerce# x-{-# INLINE happyOut118 #-}-happyIn119 :: (Kind L) -> (HappyAbsSyn )-happyIn119 x = unsafeCoerce# x-{-# INLINE happyIn119 #-}-happyOut119 :: (HappyAbsSyn ) -> (Kind L)-happyOut119 x = unsafeCoerce# x-{-# INLINE happyOut119 #-}-happyIn120 :: (Kind L) -> (HappyAbsSyn )-happyIn120 x = unsafeCoerce# x-{-# INLINE happyIn120 #-}-happyOut120 :: (HappyAbsSyn ) -> (Kind L)-happyOut120 x = unsafeCoerce# x-{-# INLINE happyOut120 #-}-happyIn121 :: (Kind L) -> (HappyAbsSyn )-happyIn121 x = unsafeCoerce# x-{-# INLINE happyIn121 #-}-happyOut121 :: (HappyAbsSyn ) -> (Kind L)-happyOut121 x = unsafeCoerce# x-{-# INLINE happyOut121 #-}-happyIn122 :: ((Maybe (Kind L), [S])) -> (HappyAbsSyn )-happyIn122 x = unsafeCoerce# x-{-# INLINE happyIn122 #-}-happyOut122 :: (HappyAbsSyn ) -> ((Maybe (Kind L), [S]))-happyOut122 x = unsafeCoerce# x-{-# INLINE happyOut122 #-}-happyIn123 :: ((Maybe [ClassDecl L],[S],Maybe L)) -> (HappyAbsSyn )-happyIn123 x = unsafeCoerce# x-{-# INLINE happyIn123 #-}-happyOut123 :: (HappyAbsSyn ) -> ((Maybe [ClassDecl L],[S],Maybe L))-happyOut123 x = unsafeCoerce# x-{-# INLINE happyOut123 #-}-happyIn124 :: (([ClassDecl L],[S])) -> (HappyAbsSyn )-happyIn124 x = unsafeCoerce# x-{-# INLINE happyIn124 #-}-happyOut124 :: (HappyAbsSyn ) -> (([ClassDecl L],[S]))-happyOut124 x = unsafeCoerce# x-{-# INLINE happyOut124 #-}-happyIn125 :: (([ClassDecl L],[S])) -> (HappyAbsSyn )-happyIn125 x = unsafeCoerce# x-{-# INLINE happyIn125 #-}-happyOut125 :: (HappyAbsSyn ) -> (([ClassDecl L],[S]))-happyOut125 x = unsafeCoerce# x-{-# INLINE happyOut125 #-}-happyIn126 :: (ClassDecl L) -> (HappyAbsSyn )-happyIn126 x = unsafeCoerce# x-{-# INLINE happyIn126 #-}-happyOut126 :: (HappyAbsSyn ) -> (ClassDecl L)-happyOut126 x = unsafeCoerce# x-{-# INLINE happyOut126 #-}-happyIn127 :: (ClassDecl L) -> (HappyAbsSyn )-happyIn127 x = unsafeCoerce# x-{-# INLINE happyIn127 #-}-happyOut127 :: (HappyAbsSyn ) -> (ClassDecl L)-happyOut127 x = unsafeCoerce# x-{-# INLINE happyOut127 #-}-happyIn128 :: ((Maybe [InstDecl L],[S],Maybe L)) -> (HappyAbsSyn )-happyIn128 x = unsafeCoerce# x-{-# INLINE happyIn128 #-}-happyOut128 :: (HappyAbsSyn ) -> ((Maybe [InstDecl L],[S],Maybe L))-happyOut128 x = unsafeCoerce# x-{-# INLINE happyOut128 #-}-happyIn129 :: (([InstDecl L],[S])) -> (HappyAbsSyn )-happyIn129 x = unsafeCoerce# x-{-# INLINE happyIn129 #-}-happyOut129 :: (HappyAbsSyn ) -> (([InstDecl L],[S]))-happyOut129 x = unsafeCoerce# x-{-# INLINE happyOut129 #-}-happyIn130 :: (([InstDecl L],[S])) -> (HappyAbsSyn )-happyIn130 x = unsafeCoerce# x-{-# INLINE happyIn130 #-}-happyOut130 :: (HappyAbsSyn ) -> (([InstDecl L],[S]))-happyOut130 x = unsafeCoerce# x-{-# INLINE happyOut130 #-}-happyIn131 :: (InstDecl L) -> (HappyAbsSyn )-happyIn131 x = unsafeCoerce# x-{-# INLINE happyIn131 #-}-happyOut131 :: (HappyAbsSyn ) -> (InstDecl L)-happyOut131 x = unsafeCoerce# x-{-# INLINE happyOut131 #-}-happyIn132 :: (InstDecl L) -> (HappyAbsSyn )-happyIn132 x = unsafeCoerce# x-{-# INLINE happyIn132 #-}-happyOut132 :: (HappyAbsSyn ) -> (InstDecl L)-happyOut132 x = unsafeCoerce# x-{-# INLINE happyOut132 #-}-happyIn133 :: (Decl L) -> (HappyAbsSyn )-happyIn133 x = unsafeCoerce# x-{-# INLINE happyIn133 #-}-happyOut133 :: (HappyAbsSyn ) -> (Decl L)-happyOut133 x = unsafeCoerce# x-{-# INLINE happyOut133 #-}-happyIn134 :: ((Maybe (Binds L),[S])) -> (HappyAbsSyn )-happyIn134 x = unsafeCoerce# x-{-# INLINE happyIn134 #-}-happyOut134 :: (HappyAbsSyn ) -> ((Maybe (Binds L),[S]))-happyOut134 x = unsafeCoerce# x-{-# INLINE happyOut134 #-}-happyIn135 :: ((Maybe (Type L),[S])) -> (HappyAbsSyn )-happyIn135 x = unsafeCoerce# x-{-# INLINE happyIn135 #-}-happyOut135 :: (HappyAbsSyn ) -> ((Maybe (Type L),[S]))-happyOut135 x = unsafeCoerce# x-{-# INLINE happyOut135 #-}-happyIn136 :: (Rhs L) -> (HappyAbsSyn )-happyIn136 x = unsafeCoerce# x-{-# INLINE happyIn136 #-}-happyOut136 :: (HappyAbsSyn ) -> (Rhs L)-happyOut136 x = unsafeCoerce# x-{-# INLINE happyOut136 #-}-happyIn137 :: (([GuardedRhs L],L)) -> (HappyAbsSyn )-happyIn137 x = unsafeCoerce# x-{-# INLINE happyIn137 #-}-happyOut137 :: (HappyAbsSyn ) -> (([GuardedRhs L],L))-happyOut137 x = unsafeCoerce# x-{-# INLINE happyOut137 #-}-happyIn138 :: (GuardedRhs L) -> (HappyAbsSyn )-happyIn138 x = unsafeCoerce# x-{-# INLINE happyIn138 #-}-happyOut138 :: (HappyAbsSyn ) -> (GuardedRhs L)-happyOut138 x = unsafeCoerce# x-{-# INLINE happyOut138 #-}-happyIn139 :: (Exp L) -> (HappyAbsSyn )-happyIn139 x = unsafeCoerce# x-{-# INLINE happyIn139 #-}-happyOut139 :: (HappyAbsSyn ) -> (Exp L)-happyOut139 x = unsafeCoerce# x-{-# INLINE happyOut139 #-}-happyIn140 :: (PExp L) -> (HappyAbsSyn )-happyIn140 x = unsafeCoerce# x-{-# INLINE happyIn140 #-}-happyOut140 :: (HappyAbsSyn ) -> (PExp L)-happyOut140 x = unsafeCoerce# x-{-# INLINE happyOut140 #-}-happyIn141 :: (PExp L) -> (HappyAbsSyn )-happyIn141 x = unsafeCoerce# x-{-# INLINE happyIn141 #-}-happyOut141 :: (HappyAbsSyn ) -> (PExp L)-happyOut141 x = unsafeCoerce# x-{-# INLINE happyOut141 #-}-happyIn142 :: (PExp L) -> (HappyAbsSyn )-happyIn142 x = unsafeCoerce# x-{-# INLINE happyIn142 #-}-happyOut142 :: (HappyAbsSyn ) -> (PExp L)-happyOut142 x = unsafeCoerce# x-{-# INLINE happyOut142 #-}-happyIn143 :: (PExp L) -> (HappyAbsSyn )-happyIn143 x = unsafeCoerce# x-{-# INLINE happyIn143 #-}-happyOut143 :: (HappyAbsSyn ) -> (PExp L)-happyOut143 x = unsafeCoerce# x-{-# INLINE happyOut143 #-}-happyIn144 :: (PExp L) -> (HappyAbsSyn )-happyIn144 x = unsafeCoerce# x-{-# INLINE happyIn144 #-}-happyOut144 :: (HappyAbsSyn ) -> (PExp L)-happyOut144 x = unsafeCoerce# x-{-# INLINE happyOut144 #-}-happyIn145 :: ([S]) -> (HappyAbsSyn )-happyIn145 x = unsafeCoerce# x-{-# INLINE happyIn145 #-}-happyOut145 :: (HappyAbsSyn ) -> ([S])-happyOut145 x = unsafeCoerce# x-{-# INLINE happyOut145 #-}-happyIn146 :: ([S]) -> (HappyAbsSyn )-happyIn146 x = unsafeCoerce# x-{-# INLINE happyIn146 #-}-happyOut146 :: (HappyAbsSyn ) -> ([S])-happyOut146 x = unsafeCoerce# x-{-# INLINE happyOut146 #-}-happyIn147 :: (PExp L) -> (HappyAbsSyn )-happyIn147 x = unsafeCoerce# x-{-# INLINE happyIn147 #-}-happyOut147 :: (HappyAbsSyn ) -> (PExp L)-happyOut147 x = unsafeCoerce# x-{-# INLINE happyOut147 #-}-happyIn148 :: (PExp L) -> (HappyAbsSyn )-happyIn148 x = unsafeCoerce# x-{-# INLINE happyIn148 #-}-happyOut148 :: (HappyAbsSyn ) -> (PExp L)-happyOut148 x = unsafeCoerce# x-{-# INLINE happyOut148 #-}-happyIn149 :: (PExp L) -> (HappyAbsSyn )-happyIn149 x = unsafeCoerce# x-{-# INLINE happyIn149 #-}-happyOut149 :: (HappyAbsSyn ) -> (PExp L)-happyOut149 x = unsafeCoerce# x-{-# INLINE happyOut149 #-}-happyIn150 :: ([Pat L]) -> (HappyAbsSyn )-happyIn150 x = unsafeCoerce# x-{-# INLINE happyIn150 #-}-happyOut150 :: (HappyAbsSyn ) -> ([Pat L])-happyOut150 x = unsafeCoerce# x-{-# INLINE happyOut150 #-}-happyIn151 :: (Pat L) -> (HappyAbsSyn )-happyIn151 x = unsafeCoerce# x-{-# INLINE happyIn151 #-}-happyOut151 :: (HappyAbsSyn ) -> (Pat L)-happyOut151 x = unsafeCoerce# x-{-# INLINE happyOut151 #-}-happyIn152 :: (PExp L) -> (HappyAbsSyn )-happyIn152 x = unsafeCoerce# x-{-# INLINE happyIn152 #-}-happyOut152 :: (HappyAbsSyn ) -> (PExp L)-happyOut152 x = unsafeCoerce# x-{-# INLINE happyOut152 #-}-happyIn153 :: (PExp L) -> (HappyAbsSyn )-happyIn153 x = unsafeCoerce# x-{-# INLINE happyIn153 #-}-happyOut153 :: (HappyAbsSyn ) -> (PExp L)-happyOut153 x = unsafeCoerce# x-{-# INLINE happyOut153 #-}-happyIn154 :: (PExp L) -> (HappyAbsSyn )-happyIn154 x = unsafeCoerce# x-{-# INLINE happyIn154 #-}-happyOut154 :: (HappyAbsSyn ) -> (PExp L)-happyOut154 x = unsafeCoerce# x-{-# INLINE happyOut154 #-}-happyIn155 :: ([S]) -> (HappyAbsSyn )-happyIn155 x = unsafeCoerce# x-{-# INLINE happyIn155 #-}-happyOut155 :: (HappyAbsSyn ) -> ([S])-happyOut155 x = unsafeCoerce# x-{-# INLINE happyOut155 #-}-happyIn156 :: (PExp L) -> (HappyAbsSyn )-happyIn156 x = unsafeCoerce# x-{-# INLINE happyIn156 #-}-happyOut156 :: (HappyAbsSyn ) -> (PExp L)-happyOut156 x = unsafeCoerce# x-{-# INLINE happyOut156 #-}-happyIn157 :: (([Maybe (PExp L)],[S])) -> (HappyAbsSyn )-happyIn157 x = unsafeCoerce# x-{-# INLINE happyIn157 #-}-happyOut157 :: (HappyAbsSyn ) -> (([Maybe (PExp L)],[S]))-happyOut157 x = unsafeCoerce# x-{-# INLINE happyOut157 #-}-happyIn158 :: (([PExp L],[S])) -> (HappyAbsSyn )-happyIn158 x = unsafeCoerce# x-{-# INLINE happyIn158 #-}-happyOut158 :: (HappyAbsSyn ) -> (([PExp L],[S]))-happyOut158 x = unsafeCoerce# x-{-# INLINE happyOut158 #-}-happyIn159 :: (PExp L) -> (HappyAbsSyn )-happyIn159 x = unsafeCoerce# x-{-# INLINE happyIn159 #-}-happyOut159 :: (HappyAbsSyn ) -> (PExp L)-happyOut159 x = unsafeCoerce# x-{-# INLINE happyOut159 #-}-happyIn160 :: (PExp L) -> (HappyAbsSyn )-happyIn160 x = unsafeCoerce# x-{-# INLINE happyIn160 #-}-happyOut160 :: (HappyAbsSyn ) -> (PExp L)-happyOut160 x = unsafeCoerce# x-{-# INLINE happyOut160 #-}-happyIn161 :: ([PExp L]) -> (HappyAbsSyn )-happyIn161 x = unsafeCoerce# x-{-# INLINE happyIn161 #-}-happyOut161 :: (HappyAbsSyn ) -> ([PExp L])-happyOut161 x = unsafeCoerce# x-{-# INLINE happyOut161 #-}-happyIn162 :: (PExp L) -> (HappyAbsSyn )-happyIn162 x = unsafeCoerce# x-{-# INLINE happyIn162 #-}-happyOut162 :: (HappyAbsSyn ) -> (PExp L)-happyOut162 x = unsafeCoerce# x-{-# INLINE happyOut162 #-}-happyIn163 :: (XName L) -> (HappyAbsSyn )-happyIn163 x = unsafeCoerce# x-{-# INLINE happyIn163 #-}-happyOut163 :: (HappyAbsSyn ) -> (XName L)-happyOut163 x = unsafeCoerce# x-{-# INLINE happyOut163 #-}-happyIn164 :: (Loc String) -> (HappyAbsSyn )-happyIn164 x = unsafeCoerce# x-{-# INLINE happyIn164 #-}-happyOut164 :: (HappyAbsSyn ) -> (Loc String)-happyOut164 x = unsafeCoerce# x-{-# INLINE happyOut164 #-}-happyIn165 :: (Loc String) -> (HappyAbsSyn )-happyIn165 x = unsafeCoerce# x-{-# INLINE happyIn165 #-}-happyOut165 :: (HappyAbsSyn ) -> (Loc String)-happyOut165 x = unsafeCoerce# x-{-# INLINE happyOut165 #-}-happyIn166 :: ([ParseXAttr L]) -> (HappyAbsSyn )-happyIn166 x = unsafeCoerce# x-{-# INLINE happyIn166 #-}-happyOut166 :: (HappyAbsSyn ) -> ([ParseXAttr L])-happyOut166 x = unsafeCoerce# x-{-# INLINE happyOut166 #-}-happyIn167 :: (ParseXAttr L) -> (HappyAbsSyn )-happyIn167 x = unsafeCoerce# x-{-# INLINE happyIn167 #-}-happyOut167 :: (HappyAbsSyn ) -> (ParseXAttr L)-happyOut167 x = unsafeCoerce# x-{-# INLINE happyOut167 #-}-happyIn168 :: (Maybe (PExp L)) -> (HappyAbsSyn )-happyIn168 x = unsafeCoerce# x-{-# INLINE happyIn168 #-}-happyOut168 :: (HappyAbsSyn ) -> (Maybe (PExp L))-happyOut168 x = unsafeCoerce# x-{-# INLINE happyOut168 #-}-happyIn169 :: (L -> PExp L) -> (HappyAbsSyn )-happyIn169 x = unsafeCoerce# x-{-# INLINE happyIn169 #-}-happyOut169 :: (HappyAbsSyn ) -> (L -> PExp L)-happyOut169 x = unsafeCoerce# x-{-# INLINE happyOut169 #-}-happyIn170 :: (([PExp L],[S])) -> (HappyAbsSyn )-happyIn170 x = unsafeCoerce# x-{-# INLINE happyIn170 #-}-happyOut170 :: (HappyAbsSyn ) -> (([PExp L],[S]))-happyOut170 x = unsafeCoerce# x-{-# INLINE happyOut170 #-}-happyIn171 :: (([[QualStmt L]],[S])) -> (HappyAbsSyn )-happyIn171 x = unsafeCoerce# x-{-# INLINE happyIn171 #-}-happyOut171 :: (HappyAbsSyn ) -> (([[QualStmt L]],[S]))-happyOut171 x = unsafeCoerce# x-{-# INLINE happyOut171 #-}-happyIn172 :: (([QualStmt L],[S])) -> (HappyAbsSyn )-happyIn172 x = unsafeCoerce# x-{-# INLINE happyIn172 #-}-happyOut172 :: (HappyAbsSyn ) -> (([QualStmt L],[S]))-happyOut172 x = unsafeCoerce# x-{-# INLINE happyOut172 #-}-happyIn173 :: (QualStmt L) -> (HappyAbsSyn )-happyIn173 x = unsafeCoerce# x-{-# INLINE happyIn173 #-}-happyOut173 :: (HappyAbsSyn ) -> (QualStmt L)-happyOut173 x = unsafeCoerce# x-{-# INLINE happyOut173 #-}-happyIn174 :: (QualStmt L) -> (HappyAbsSyn )-happyIn174 x = unsafeCoerce# x-{-# INLINE happyIn174 #-}-happyOut174 :: (HappyAbsSyn ) -> (QualStmt L)-happyOut174 x = unsafeCoerce# x-{-# INLINE happyOut174 #-}-happyIn175 :: (([Stmt L],[S])) -> (HappyAbsSyn )-happyIn175 x = unsafeCoerce# x-{-# INLINE happyIn175 #-}-happyOut175 :: (HappyAbsSyn ) -> (([Stmt L],[S]))-happyOut175 x = unsafeCoerce# x-{-# INLINE happyOut175 #-}-happyIn176 :: (Stmt L) -> (HappyAbsSyn )-happyIn176 x = unsafeCoerce# x-{-# INLINE happyIn176 #-}-happyOut176 :: (HappyAbsSyn ) -> (Stmt L)-happyOut176 x = unsafeCoerce# x-{-# INLINE happyOut176 #-}-happyIn177 :: (([Alt L],L,[S])) -> (HappyAbsSyn )-happyIn177 x = unsafeCoerce# x-{-# INLINE happyIn177 #-}-happyOut177 :: (HappyAbsSyn ) -> (([Alt L],L,[S]))-happyOut177 x = unsafeCoerce# x-{-# INLINE happyOut177 #-}-happyIn178 :: (([Alt L],[S])) -> (HappyAbsSyn )-happyIn178 x = unsafeCoerce# x-{-# INLINE happyIn178 #-}-happyOut178 :: (HappyAbsSyn ) -> (([Alt L],[S]))-happyOut178 x = unsafeCoerce# x-{-# INLINE happyOut178 #-}-happyIn179 :: (([Alt L],[S])) -> (HappyAbsSyn )-happyIn179 x = unsafeCoerce# x-{-# INLINE happyIn179 #-}-happyOut179 :: (HappyAbsSyn ) -> (([Alt L],[S]))-happyOut179 x = unsafeCoerce# x-{-# INLINE happyOut179 #-}-happyIn180 :: (Alt L) -> (HappyAbsSyn )-happyIn180 x = unsafeCoerce# x-{-# INLINE happyIn180 #-}-happyOut180 :: (HappyAbsSyn ) -> (Alt L)-happyOut180 x = unsafeCoerce# x-{-# INLINE happyOut180 #-}-happyIn181 :: (GuardedAlts L) -> (HappyAbsSyn )-happyIn181 x = unsafeCoerce# x-{-# INLINE happyIn181 #-}-happyOut181 :: (HappyAbsSyn ) -> (GuardedAlts L)-happyOut181 x = unsafeCoerce# x-{-# INLINE happyOut181 #-}-happyIn182 :: (([GuardedAlt L],L)) -> (HappyAbsSyn )-happyIn182 x = unsafeCoerce# x-{-# INLINE happyIn182 #-}-happyOut182 :: (HappyAbsSyn ) -> (([GuardedAlt L],L))-happyOut182 x = unsafeCoerce# x-{-# INLINE happyOut182 #-}-happyIn183 :: (GuardedAlt L) -> (HappyAbsSyn )-happyIn183 x = unsafeCoerce# x-{-# INLINE happyIn183 #-}-happyOut183 :: (HappyAbsSyn ) -> (GuardedAlt L)-happyOut183 x = unsafeCoerce# x-{-# INLINE happyOut183 #-}-happyIn184 :: (Pat L) -> (HappyAbsSyn )-happyIn184 x = unsafeCoerce# x-{-# INLINE happyIn184 #-}-happyOut184 :: (HappyAbsSyn ) -> (Pat L)-happyOut184 x = unsafeCoerce# x-{-# INLINE happyOut184 #-}-happyIn185 :: (([Stmt L],L,[S])) -> (HappyAbsSyn )-happyIn185 x = unsafeCoerce# x-{-# INLINE happyIn185 #-}-happyOut185 :: (HappyAbsSyn ) -> (([Stmt L],L,[S]))-happyOut185 x = unsafeCoerce# x-{-# INLINE happyOut185 #-}-happyIn186 :: (([Stmt L],[S])) -> (HappyAbsSyn )-happyIn186 x = unsafeCoerce# x-{-# INLINE happyIn186 #-}-happyOut186 :: (HappyAbsSyn ) -> (([Stmt L],[S]))-happyOut186 x = unsafeCoerce# x-{-# INLINE happyOut186 #-}-happyIn187 :: (([Stmt L],[S])) -> (HappyAbsSyn )-happyIn187 x = unsafeCoerce# x-{-# INLINE happyIn187 #-}-happyOut187 :: (HappyAbsSyn ) -> (([Stmt L],[S]))-happyOut187 x = unsafeCoerce# x-{-# INLINE happyOut187 #-}-happyIn188 :: (Stmt L) -> (HappyAbsSyn )-happyIn188 x = unsafeCoerce# x-{-# INLINE happyIn188 #-}-happyOut188 :: (HappyAbsSyn ) -> (Stmt L)-happyOut188 x = unsafeCoerce# x-{-# INLINE happyOut188 #-}-happyIn189 :: (([PFieldUpdate L],[S])) -> (HappyAbsSyn )-happyIn189 x = unsafeCoerce# x-{-# INLINE happyIn189 #-}-happyOut189 :: (HappyAbsSyn ) -> (([PFieldUpdate L],[S]))-happyOut189 x = unsafeCoerce# x-{-# INLINE happyOut189 #-}-happyIn190 :: (PFieldUpdate L) -> (HappyAbsSyn )-happyIn190 x = unsafeCoerce# x-{-# INLINE happyIn190 #-}-happyOut190 :: (HappyAbsSyn ) -> (PFieldUpdate L)-happyOut190 x = unsafeCoerce# x-{-# INLINE happyOut190 #-}-happyIn191 :: (([IPBind L],[S])) -> (HappyAbsSyn )-happyIn191 x = unsafeCoerce# x-{-# INLINE happyIn191 #-}-happyOut191 :: (HappyAbsSyn ) -> (([IPBind L],[S]))-happyOut191 x = unsafeCoerce# x-{-# INLINE happyOut191 #-}-happyIn192 :: (([IPBind L],[S])) -> (HappyAbsSyn )-happyIn192 x = unsafeCoerce# x-{-# INLINE happyIn192 #-}-happyOut192 :: (HappyAbsSyn ) -> (([IPBind L],[S]))-happyOut192 x = unsafeCoerce# x-{-# INLINE happyOut192 #-}-happyIn193 :: (IPBind L) -> (HappyAbsSyn )-happyIn193 x = unsafeCoerce# x-{-# INLINE happyIn193 #-}-happyOut193 :: (HappyAbsSyn ) -> (IPBind L)-happyOut193 x = unsafeCoerce# x-{-# INLINE happyOut193 #-}-happyIn194 :: (PExp L) -> (HappyAbsSyn )-happyIn194 x = unsafeCoerce# x-{-# INLINE happyIn194 #-}-happyOut194 :: (HappyAbsSyn ) -> (PExp L)-happyOut194 x = unsafeCoerce# x-{-# INLINE happyOut194 #-}-happyIn195 :: (Name L) -> (HappyAbsSyn )-happyIn195 x = unsafeCoerce# x-{-# INLINE happyIn195 #-}-happyOut195 :: (HappyAbsSyn ) -> (Name L)-happyOut195 x = unsafeCoerce# x-{-# INLINE happyOut195 #-}-happyIn196 :: (Name L) -> (HappyAbsSyn )-happyIn196 x = unsafeCoerce# x-{-# INLINE happyIn196 #-}-happyOut196 :: (HappyAbsSyn ) -> (Name L)-happyOut196 x = unsafeCoerce# x-{-# INLINE happyOut196 #-}-happyIn197 :: (QName L) -> (HappyAbsSyn )-happyIn197 x = unsafeCoerce# x-{-# INLINE happyIn197 #-}-happyOut197 :: (HappyAbsSyn ) -> (QName L)-happyOut197 x = unsafeCoerce# x-{-# INLINE happyOut197 #-}-happyIn198 :: (IPName L) -> (HappyAbsSyn )-happyIn198 x = unsafeCoerce# x-{-# INLINE happyIn198 #-}-happyOut198 :: (HappyAbsSyn ) -> (IPName L)-happyOut198 x = unsafeCoerce# x-{-# INLINE happyOut198 #-}-happyIn199 :: (Name L) -> (HappyAbsSyn )-happyIn199 x = unsafeCoerce# x-{-# INLINE happyIn199 #-}-happyOut199 :: (HappyAbsSyn ) -> (Name L)-happyOut199 x = unsafeCoerce# x-{-# INLINE happyOut199 #-}-happyIn200 :: (QName L) -> (HappyAbsSyn )-happyIn200 x = unsafeCoerce# x-{-# INLINE happyIn200 #-}-happyOut200 :: (HappyAbsSyn ) -> (QName L)-happyOut200 x = unsafeCoerce# x-{-# INLINE happyOut200 #-}-happyIn201 :: (Name L) -> (HappyAbsSyn )-happyIn201 x = unsafeCoerce# x-{-# INLINE happyIn201 #-}-happyOut201 :: (HappyAbsSyn ) -> (Name L)-happyOut201 x = unsafeCoerce# x-{-# INLINE happyOut201 #-}-happyIn202 :: (QName L) -> (HappyAbsSyn )-happyIn202 x = unsafeCoerce# x-{-# INLINE happyIn202 #-}-happyOut202 :: (HappyAbsSyn ) -> (QName L)-happyOut202 x = unsafeCoerce# x-{-# INLINE happyOut202 #-}-happyIn203 :: (QName L) -> (HappyAbsSyn )-happyIn203 x = unsafeCoerce# x-{-# INLINE happyIn203 #-}-happyOut203 :: (HappyAbsSyn ) -> (QName L)-happyOut203 x = unsafeCoerce# x-{-# INLINE happyOut203 #-}-happyIn204 :: (Name L) -> (HappyAbsSyn )-happyIn204 x = unsafeCoerce# x-{-# INLINE happyIn204 #-}-happyOut204 :: (HappyAbsSyn ) -> (Name L)-happyOut204 x = unsafeCoerce# x-{-# INLINE happyOut204 #-}-happyIn205 :: (QName L) -> (HappyAbsSyn )-happyIn205 x = unsafeCoerce# x-{-# INLINE happyIn205 #-}-happyOut205 :: (HappyAbsSyn ) -> (QName L)-happyOut205 x = unsafeCoerce# x-{-# INLINE happyOut205 #-}-happyIn206 :: (Op L) -> (HappyAbsSyn )-happyIn206 x = unsafeCoerce# x-{-# INLINE happyIn206 #-}-happyOut206 :: (HappyAbsSyn ) -> (Op L)-happyOut206 x = unsafeCoerce# x-{-# INLINE happyOut206 #-}-happyIn207 :: (QOp L) -> (HappyAbsSyn )-happyIn207 x = unsafeCoerce# x-{-# INLINE happyIn207 #-}-happyOut207 :: (HappyAbsSyn ) -> (QOp L)-happyOut207 x = unsafeCoerce# x-{-# INLINE happyOut207 #-}-happyIn208 :: (QOp L) -> (HappyAbsSyn )-happyIn208 x = unsafeCoerce# x-{-# INLINE happyIn208 #-}-happyOut208 :: (HappyAbsSyn ) -> (QOp L)-happyOut208 x = unsafeCoerce# x-{-# INLINE happyOut208 #-}-happyIn209 :: (QName L) -> (HappyAbsSyn )-happyIn209 x = unsafeCoerce# x-{-# INLINE happyIn209 #-}-happyOut209 :: (HappyAbsSyn ) -> (QName L)-happyOut209 x = unsafeCoerce# x-{-# INLINE happyOut209 #-}-happyIn210 :: (QName L) -> (HappyAbsSyn )-happyIn210 x = unsafeCoerce# x-{-# INLINE happyIn210 #-}-happyOut210 :: (HappyAbsSyn ) -> (QName L)-happyOut210 x = unsafeCoerce# x-{-# INLINE happyOut210 #-}-happyIn211 :: (Name L) -> (HappyAbsSyn )-happyIn211 x = unsafeCoerce# x-{-# INLINE happyIn211 #-}-happyOut211 :: (HappyAbsSyn ) -> (Name L)-happyOut211 x = unsafeCoerce# x-{-# INLINE happyOut211 #-}-happyIn212 :: (Name L) -> (HappyAbsSyn )-happyIn212 x = unsafeCoerce# x-{-# INLINE happyIn212 #-}-happyOut212 :: (HappyAbsSyn ) -> (Name L)-happyOut212 x = unsafeCoerce# x-{-# INLINE happyOut212 #-}-happyIn213 :: (IPName L) -> (HappyAbsSyn )-happyIn213 x = unsafeCoerce# x-{-# INLINE happyIn213 #-}-happyOut213 :: (HappyAbsSyn ) -> (IPName L)-happyOut213 x = unsafeCoerce# x-{-# INLINE happyOut213 #-}-happyIn214 :: (QName L) -> (HappyAbsSyn )-happyIn214 x = unsafeCoerce# x-{-# INLINE happyIn214 #-}-happyOut214 :: (HappyAbsSyn ) -> (QName L)-happyOut214 x = unsafeCoerce# x-{-# INLINE happyOut214 #-}-happyIn215 :: (Name L) -> (HappyAbsSyn )-happyIn215 x = unsafeCoerce# x-{-# INLINE happyIn215 #-}-happyOut215 :: (HappyAbsSyn ) -> (Name L)-happyOut215 x = unsafeCoerce# x-{-# INLINE happyOut215 #-}-happyIn216 :: (QName L) -> (HappyAbsSyn )-happyIn216 x = unsafeCoerce# x-{-# INLINE happyIn216 #-}-happyOut216 :: (HappyAbsSyn ) -> (QName L)-happyOut216 x = unsafeCoerce# x-{-# INLINE happyOut216 #-}-happyIn217 :: (Name L) -> (HappyAbsSyn )-happyIn217 x = unsafeCoerce# x-{-# INLINE happyIn217 #-}-happyOut217 :: (HappyAbsSyn ) -> (Name L)-happyOut217 x = unsafeCoerce# x-{-# INLINE happyOut217 #-}-happyIn218 :: (QName L) -> (HappyAbsSyn )-happyIn218 x = unsafeCoerce# x-{-# INLINE happyIn218 #-}-happyOut218 :: (HappyAbsSyn ) -> (QName L)-happyOut218 x = unsafeCoerce# x-{-# INLINE happyOut218 #-}-happyIn219 :: (QName L) -> (HappyAbsSyn )-happyIn219 x = unsafeCoerce# x-{-# INLINE happyIn219 #-}-happyOut219 :: (HappyAbsSyn ) -> (QName L)-happyOut219 x = unsafeCoerce# x-{-# INLINE happyOut219 #-}-happyIn220 :: (Name L) -> (HappyAbsSyn )-happyIn220 x = unsafeCoerce# x-{-# INLINE happyIn220 #-}-happyOut220 :: (HappyAbsSyn ) -> (Name L)-happyOut220 x = unsafeCoerce# x-{-# INLINE happyOut220 #-}-happyIn221 :: (Name L) -> (HappyAbsSyn )-happyIn221 x = unsafeCoerce# x-{-# INLINE happyIn221 #-}-happyOut221 :: (HappyAbsSyn ) -> (Name L)-happyOut221 x = unsafeCoerce# x-{-# INLINE happyOut221 #-}-happyIn222 :: (QName L) -> (HappyAbsSyn )-happyIn222 x = unsafeCoerce# x-{-# INLINE happyIn222 #-}-happyOut222 :: (HappyAbsSyn ) -> (QName L)-happyOut222 x = unsafeCoerce# x-{-# INLINE happyOut222 #-}-happyIn223 :: (Literal L) -> (HappyAbsSyn )-happyIn223 x = unsafeCoerce# x-{-# INLINE happyIn223 #-}-happyOut223 :: (HappyAbsSyn ) -> (Literal L)-happyOut223 x = unsafeCoerce# x-{-# INLINE happyOut223 #-}-happyIn224 :: (S) -> (HappyAbsSyn )-happyIn224 x = unsafeCoerce# x-{-# INLINE happyIn224 #-}-happyOut224 :: (HappyAbsSyn ) -> (S)-happyOut224 x = unsafeCoerce# x-{-# INLINE happyOut224 #-}-happyIn225 :: (S) -> (HappyAbsSyn )-happyIn225 x = unsafeCoerce# x-{-# INLINE happyIn225 #-}-happyOut225 :: (HappyAbsSyn ) -> (S)-happyOut225 x = unsafeCoerce# x-{-# INLINE happyOut225 #-}-happyIn226 :: (ModuleName L) -> (HappyAbsSyn )-happyIn226 x = unsafeCoerce# x-{-# INLINE happyIn226 #-}-happyOut226 :: (HappyAbsSyn ) -> (ModuleName L)-happyOut226 x = unsafeCoerce# x-{-# INLINE happyOut226 #-}-happyIn227 :: (Name L) -> (HappyAbsSyn )-happyIn227 x = unsafeCoerce# x-{-# INLINE happyIn227 #-}-happyOut227 :: (HappyAbsSyn ) -> (Name L)-happyOut227 x = unsafeCoerce# x-{-# INLINE happyOut227 #-}-happyIn228 :: (QName L) -> (HappyAbsSyn )-happyIn228 x = unsafeCoerce# x-{-# INLINE happyIn228 #-}-happyOut228 :: (HappyAbsSyn ) -> (QName L)-happyOut228 x = unsafeCoerce# x-{-# INLINE happyOut228 #-}-happyIn229 :: (Name L) -> (HappyAbsSyn )-happyIn229 x = unsafeCoerce# x-{-# INLINE happyIn229 #-}-happyOut229 :: (HappyAbsSyn ) -> (Name L)-happyOut229 x = unsafeCoerce# x-{-# INLINE happyOut229 #-}-happyIn230 :: (Name L) -> (HappyAbsSyn )-happyIn230 x = unsafeCoerce# x-{-# INLINE happyIn230 #-}-happyOut230 :: (HappyAbsSyn ) -> (Name L)-happyOut230 x = unsafeCoerce# x-{-# INLINE happyOut230 #-}-happyIn231 :: (QName L) -> (HappyAbsSyn )-happyIn231 x = unsafeCoerce# x-{-# INLINE happyIn231 #-}-happyOut231 :: (HappyAbsSyn ) -> (QName L)-happyOut231 x = unsafeCoerce# x-{-# INLINE happyOut231 #-}-happyIn232 :: (Name L) -> (HappyAbsSyn )-happyIn232 x = unsafeCoerce# x-{-# INLINE happyIn232 #-}-happyOut232 :: (HappyAbsSyn ) -> (Name L)-happyOut232 x = unsafeCoerce# x-{-# INLINE happyOut232 #-}-happyInTok :: Loc Token -> (HappyAbsSyn )-happyInTok x = unsafeCoerce# x-{-# INLINE happyInTok #-}-happyOutTok :: (HappyAbsSyn ) -> Loc Token-happyOutTok x = unsafeCoerce# x-{-# INLINE happyOutTok #-}---happyActOffsets :: HappyAddr-happyActOffsets = HappyA# "\x00\x00\x93\x13\x1a\x13\xfe\x0a\x18\x1b\xbd\x10\x00\x00\x00\x00\x00\x00\xcf\x06\x14\x04\x3d\x07\xb4\x06\x00\x00\x10\x07\x00\x00\x00\x00\x86\x0c\x00\x00\x00\x00\x00\x00\x8d\x18\x00\x00\x1e\x07\x00\x00\x00\x00\x0e\x07\xac\x06\x00\x00\x1e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\x0d\x0b\x02\x57\x0e\x00\x00\x32\x18\x8d\x18\x8d\x18\x8d\x18\x93\x13\x00\x00\x93\x13\x93\x13\x93\x13\x18\x1b\x00\x00\x6a\x1c\x06\x1e\x00\x00\xb8\x18\x93\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x93\x13\x15\x07\x00\x00\x00\x00\x00\x00\x93\x13\x13\x07\x11\x07\x32\x18\x11\x07\x00\x00\x1d\x07\x1b\x07\x1a\x07\x00\x00\x00\x00\x8b\x19\x00\x00\x00\x00\x00\x00\xa1\x06\x00\x00\x18\x1b\xf6\x06\x00\x00\x00\x00\x00\x00\x00\x00\x31\x19\xef\x19\xee\x1a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x07\x98\x06\x37\x1a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd0\x18\x8d\x18\xd6\xff\xd0\x1a\xb9\x06\x04\x07\xa9\x06\x00\x00\x00\x00\x00\x00\xd0\x1a\xf8\x06\x00\x00\x06\x18\xee\x06\xee\x06\xd9\x1d\xee\x06\xf9\x06\x7b\x1e\x7b\x1e\x3c\x1c\x00\x00\x80\x06\x80\x06\x00\x00\x80\x06\xfa\xff\x00\x00\x00\x00\xe9\x06\xb8\x18\x92\x06\x72\x05\x8d\x18\x78\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x8d\x18\xf5\x06\x2d\x00\x00\x00\xe7\x06\xd2\x06\x27\x00\x25\x00\x00\x00\xcd\x06\x63\x1e\x24\x00\xca\x06\x56\x01\xd0\x1a\x63\x1e\x63\x1e\xc0\x06\xa8\x19\x36\x1b\xc1\x1d\x00\x00\x7f\x06\x00\x00\x00\x00\x66\x06\xd0\x1a\xd0\x1a\xd0\x1a\xbc\x06\x0d\x04\x0d\x04\x86\x04\x86\x04\x00\x00\x00\x00\x93\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x63\x1e\x94\x1d\x00\x00\x00\x00\xd0\x1a\x00\x00\x00\x00\x00\x00\x4b\x05\xd0\x1a\x23\x00\x00\x00\x4b\x1f\xc5\x06\x00\x00\x00\x00\xfc\x01\xc1\x01\x00\x00\x00\x00\x35\x01\xcb\x06\xb7\x06\xee\x01\xc9\x06\xbe\x06\x00\x00\xbd\x06\x7c\x1d\x00\x00\x00\x00\x7c\x1d\x00\x00\x7c\x1d\x00\x00\x00\x00\x86\x0b\xd0\x1a\x7c\x1d\x00\x00\xc7\x06\x49\x06\x48\x06\x00\x00\x52\x0f\x52\x0f\x9d\x06\x00\x00\x8d\x18\x00\x00\x67\x06\xb3\x06\x00\x00\x5c\x06\x3b\x00\x79\x06\x00\x00\x99\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x1a\x9c\x01\xa0\x06\x00\x00\x00\x00\x96\x02\xfe\x0a\x7e\x06\x7a\x06\x97\x0d\x74\x06\x9f\x06\x9e\x06\xec\x00\x00\x00\x8d\x18\x00\x00\xd7\x17\x00\x00\x84\x06\xd6\x01\x9b\x06\x89\x06\x00\x00\x00\x00\x93\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x1d\x00\x00\x00\x00\x00\x00\x7a\x01\x00\x00\x69\x04\x53\x0d\xcb\x01\x96\x06\x95\x06\x91\x06\x90\x06\x8e\x06\x00\x00\x8d\x06\x8d\x18\x8b\x06\x8a\x06\x36\x1b\x8d\x18\x8d\x18\x93\x13\x25\x1c\x00\x00\x93\x13\xd0\x1a\x93\x13\x93\x13\x93\x13\x93\x13\x32\x00\x81\x06\x00\x00\x94\x06\xc9\x1b\x00\x00\x07\x00\x00\x00\x08\x06\x00\x00\x71\x06\x00\x00\x15\x00\x14\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x77\x02\x00\x00\x6f\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x77\x06\x00\x00\x00\x00\x00\x00\x00\x00\xd1\x0c\x00\x00\x00\x00\xc9\x01\x00\x00\x00\x00\x93\x13\x93\x13\x00\x00\x6c\x06\x6a\x06\x00\x00\xd9\x0e\x00\x00\xd9\x0e\x93\x13\x44\x10\x00\x00\x93\x13\x93\x13\x00\x00\xa1\x12\x00\x00\x00\x00\x00\x00\x00\x00\x32\x00\x00\x00\x00\x00\x76\x06\xb8\x18\xef\x16\x00\x00\x42\x06\x00\x00\x00\x00\x00\x00\x00\x00\x93\x13\x68\x06\x0f\x06\x00\x00\x93\x13\x00\x00\x93\x13\x61\x06\x62\x06\x52\x0f\x32\x00\x93\x13\x93\x13\x55\x06\xbe\x1b\x00\x00\x59\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd0\x1a\x00\x00\x00\x00\x2e\x00\x00\x00\x00\x00\xd0\x1a\x00\x00\x00\x00\x00\x00\xc9\x15\xd0\x1a\x58\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\x1e\x4b\x05\x19\x06\xfe\x05\x2e\x00\x0c\x06\x61\x04\x51\x06\x0e\x02\x00\x00\xf4\x05\x3f\x06\x00\x00\x93\x13\xa1\x12\xf0\x05\x33\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x46\x0c\xee\x05\x00\x00\x3d\x06\x4d\x06\x00\x00\x41\x06\x00\x00\x00\x00\x00\x00\x45\x06\x83\x15\x3e\x06\x3a\x06\x32\x00\x32\x00\x26\x06\x00\x00\x25\x06\x37\x1d\xd0\x1a\xcd\x05\xcb\x05\xc7\x05\xd0\x1a\x2b\x06\x3c\x06\x1a\x06\xe0\x05\x31\x06\x00\x00\x4c\x1e\x00\x00\x4c\x1e\x00\x00\x00\x00\x8d\x18\x00\x00\x27\x06\x22\x06\x00\x00\x00\x00\xdf\x04\x00\x00\x00\x00\xec\x05\x00\x00\x00\x00\x00\x00\x00\x00\x16\x06\xee\x09\x32\x00\xef\x16\xea\x05\x18\x06\x1d\x06\x1b\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x93\x13\xc0\x1e\xd0\x1a\xf7\x05\x00\x00\x97\x05\xfa\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x1d\x00\x00\xd0\x1a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x35\x19\x00\x00\x00\x00\xeb\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x1c\xf8\x05\x00\x00\x00\x00\xf6\x05\x00\x00\xe4\x05\x00\x00\xf0\x1b\xc9\x02\x46\x0c\x00\x00\x00\x00\x00\x00\x00\x00\xe9\x05\x00\x00\xbd\x01\x00\x00\xcf\x05\xe7\x05\x00\x00\x00\x00\x00\x00\xa9\x1e\xd0\x1a\x00\x00\xdd\x05\x00\x00\x72\x0c\x00\x00\x00\x00\x00\x00\xd2\x05\x2e\x00\x00\x00\x00\x00\x9a\x05\xdb\x05\x00\x00\xbb\x01\x99\x05\x7c\x05\xce\x05\xcc\x05\x23\x00\x00\x00\xc3\x05\x00\x00\xd0\x05\xc4\x05\x00\x00\x00\x00\xd9\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x52\x0f\x00\x00\x00\x00\x00\x00\x93\x13\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x98\x05\x00\x00\xba\x05\x00\x00\x03\x05\x4a\x04\x46\x04\x2c\x04\x17\x04\x0b\x04\xda\x03\xb6\x03\xb3\x03\x9c\x03\x94\x03\x91\x03\x89\x03\x69\x03\x4d\x03\x3a\x03\x11\x03\xb3\x02\x00\x00\xfe\x0a\xc6\x05\x9f\x05\xc1\x00\x00\x00\x00\x00\xb6\x05\xbd\x05\x00\x00\x00\x00\x00\x00\x28\x12\x00\x00\xd3\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x05\x00\x00\x00\x00\x00\x00\x99\x01\x00\x00\x00\x00\x93\x13\x00\x00\x0b\x1d\x00\x00\x00\x00\xd6\x05\x0e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x93\x13\x83\x05\xf0\xff\x44\x10\x44\x10\xaf\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x18\x00\x00\x00\x00\xcb\x0f\xb9\x05\x32\x00\xb7\x05\x00\x00\xa1\x05\x00\x00\x2e\x00\x00\x00\x00\x00\x00\x00\x6d\x05\x00\x00\x00\x00\x00\x00\x19\x1a\x00\x00\x00\x00\x00\x00\xb5\x05\x2e\x00\x34\x1f\x00\x00\x6d\x0b\x72\x0c\x00\x00\x00\x00\x2d\x0c\x62\x00\xab\x05\xaa\x05\x31\x19\xf2\x1c\x3a\x05\x5b\x05\x00\x00\x00\x00\xc9\x02\x55\x05\x93\x13\x93\x13\x00\x00\x00\x00\xa6\x05\x92\x05\xf2\x1c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x15\x95\x05\x32\x00\x93\x13\x5d\x05\x8f\x05\x68\x17\x72\x16\x8f\x05\x00\x00\xd0\x1a\x00\x00\x00\x00\x30\x05\x7d\x05\x92\x1e\x00\x00\xef\x1e\x81\x05\x2b\x05\x26\x05\x31\x05\x00\x00\xa6\x1a\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x28\x05\x00\x00\x2a\x05\x1c\x05\x76\x0a\x84\x05\x00\x00\x00\x00\x88\x05\x79\x05\x00\x00\x00\x00\x00\x00\x80\x05\x00\x00\x2d\x05\x00\x00\x00\x00\x00\x00\x93\x13\x6f\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x68\x05\x00\x00\x00\x00\x00\x00\x61\x1a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x0d\x00\x00\xf2\x1c\xc9\x15\x00\x00\x00\x00\x0c\x14\x71\x05\x32\x00\x00\x00\xf2\x1c\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x05\x00\x00\x00\x00\x77\x05\x98\x1c\x14\x0c\x87\x05\x00\x00\x00\x00\xc6\x1c\x02\x05\xcb\x0b\x00\x00\xc6\x1c\xc6\x1c\xff\x04\x00\x00\x00\x00\x00\x00\x0e\x01\x69\x05\x32\x00\x60\x05\x67\x05\x00\x00\x00\x00\x65\x05\x6e\x05\x13\x05\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x02\x00\x00\x3b\x00\x00\x00\x50\x05\x00\x00\x93\x13\x93\x13\x93\x13\x00\x00\x00\x00\x00\x00\xf7\x04\x21\x05\xf2\x04\x3b\x05\x00\x00\xaf\x11\x93\x13\x36\x11\x48\x05\x93\x13\x33\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x05\x53\x00\x24\x05\x00\x00\xbe\x1b\x20\x05\x00\x00\xc6\x1c\x00\x00\xfb\x01\x45\x02\x00\x00\x00\x00\x29\x05\xc6\x1c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x1a\x36\x1b\xe0\x13\x19\x05\x61\x1a\xf5\x15\x1a\x05\xe2\x04\x61\x1a\x00\x00\x00\x00\x93\x1b\x27\x05\xe8\x0b\x00\x00\xff\x03\x00\x00\x00\x00\x00\x00\x1f\x05\x00\x00\xfc\x04\x00\x00\xb8\x18\x00\x00\x00\x00\x28\x01\x00\x00\x00\x00\x00\x00\x00\x00\x15\x05\x11\x05\xca\x04\xaa\x04\x00\x00\x00\x00\x61\x1a\xf1\x04\xef\x04\xee\x04\xee\x04\x89\x14\xf8\x04\x00\x00\x00\x00\x35\x1e\xb2\x0b\xc6\x1c\xc6\x1c\x61\x1a\x9b\x01\xf8\x04\x01\x05\x00\x00\x00\x00\x00\x00\x10\x01\x00\x00\x00\x00\xb8\x18\x93\x13\x00\x00\xc7\x04\x93\x13\x74\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc6\x1c\x6b\x04\x00\x00\x00\x00\x00\x00\x00\x00\x61\x1a\x00\x00\x9b\x04\x00\x00\x00\x00\x00\x00\x00\x00\x1e\x1e\x9d\x04\x89\x04\x09\x00\xfc\x04\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x04\x00\x00\x93\x13\x00\x00\x00\x00\x00\x00\xc6\x1c\x00\x00\x00\x00\x00\x00\xcb\x04\x00\x00\x81\x1c\x00\x00\xc8\x04\xb4\x04\x00\x00\x00\x00\x00\x00\x95\x04\x4e\x1b\xb5\x04\x1e\x1e\x00\x00\x00\x00\x00\x00\xe9\x00\x00\x00\xa0\x04\x00\x00\x00\x00\x00\x00"#--happyGotoOffsets :: HappyAddr-happyGotoOffsets = HappyA# "\x02\x00\x8d\x25\x0c\x28\xaf\x01\xea\x06\x75\x22\x01\x00\xff\xff\xfe\xff\x6a\x02\xea\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xce\x09\x00\x00\x00\x00\x00\x00\xb6\x2e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x25\x20\x04\xf7\x25\x00\x00\xd2\x15\xa0\x2e\xe1\x08\x85\x2e\xf6\x27\x00\x00\x40\x25\x2a\x25\x9a\x2c\xd6\x06\xc9\x03\xce\x08\xb9\x01\x00\x00\xb7\x03\xea\x2b\xfa\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x2b\x91\xff\x00\x00\x00\x00\x00\x00\x87\x2b\x0a\x00\x8d\xff\x07\x2d\x75\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc6\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x04\xe6\x04\x4f\x08\x00\x00\x00\x00\x00\x00\x2e\x04\x00\x00\x5b\x04\x00\x00\xb2\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x0f\x5e\x2e\x00\x00\x9e\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8a\x08\xf5\xff\x00\x00\x88\x07\x31\x04\x1e\x04\x0d\x03\xfd\x03\xb6\x04\x1d\x09\x00\x09\x93\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x91\x01\x00\x00\x00\x00\xfc\xff\x96\x03\xe3\x04\x53\x03\x43\x2e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x72\x01\x2d\x2e\x51\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdc\x03\xde\x02\x00\x00\x00\x00\xfd\x01\x00\x08\x3c\x02\xdc\x01\x00\x00\x05\x09\xfe\x02\xf8\x03\x00\x00\x00\x00\x1b\x00\x10\x00\x97\x03\xec\x07\x47\x01\xd8\x07\xb2\x03\xd1\x03\xcc\x03\xa9\x03\x2f\x03\x00\x00\x00\x00\xb0\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\xa0\x03\x00\x00\x00\x00\xc2\x06\x00\x00\x00\x00\x00\x00\xca\x00\xae\x06\xec\xff\x00\x00\x1d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9a\x06\x00\x00\x00\x00\xac\x05\x00\x00\x84\x04\x00\x00\x00\x00\x1d\x03\xc4\x07\x1b\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdb\x21\x8e\x21\x00\x00\x00\x00\x12\x2e\x00\x00\x00\x00\x76\x03\x00\x00\x00\x00\xf8\x00\x00\x00\x5e\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\x8c\xff\x64\x03\x00\x00\x00\x00\x00\x00\xa4\x02\x2a\x01\x00\x00\x00\x00\x40\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xeb\x2d\x00\x00\xf1\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdc\x26\xc8\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe1\x08\x00\x00\x00\x00\xa5\x01\xd0\x2d\xba\x2d\xdd\x24\x8a\x02\x00\x00\xb0\x2c\x24\x06\x71\x2b\x24\x2b\x0e\x2b\xc1\x2a\x0a\x03\x00\x00\xc3\x04\x0f\x00\xb5\x00\x00\x00\x05\x02\x00\x00\x00\x00\xb8\x04\x00\x00\x00\x00\x00\x00\xbc\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\x88\x26\x00\x00\x00\x00\xc3\x01\x00\x00\x00\x00\xa9\x27\xab\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x6a\x26\x00\x00\x16\x26\x5e\x2a\x26\x1f\x00\x00\x48\x2a\xfb\x29\x00\x00\x41\x21\x00\x00\x00\x00\x00\x00\x00\x00\x01\x03\xb1\x04\x00\x00\x00\x00\x1b\x04\x5d\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x93\x27\x7b\xff\x00\x00\x00\x00\xe5\x29\x00\x00\x98\x29\x00\x00\x3d\x03\xf4\x20\xe1\x02\x82\x29\x35\x29\x00\x00\xbe\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x07\x00\x00\x00\x00\x7e\x03\x00\x00\x00\x00\x9c\x07\x00\x00\x00\x00\x00\x00\xfe\x00\x12\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x01\x9e\x00\x4a\x03\x4f\x03\x5f\x03\x44\x03\x00\x00\x00\x00\x00\x00\x00\x00\x1e\x03\x14\x03\x00\x00\xc7\x24\xa7\x20\x0c\x03\x57\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\xff\x13\x03\x1a\x00\xfa\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8b\x02\x36\x02\x00\x00\x00\x00\x97\x02\x6c\x02\x00\x00\x00\x00\xc1\x02\xcf\x01\x10\x06\x00\x00\x00\x00\x00\x00\xee\x03\x00\x00\x00\x00\x00\x00\xf0\x02\xee\x02\x00\x00\x22\x09\x00\x00\x1c\x04\x00\x00\x00\x00\x9f\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x03\x00\x00\x00\x00\x00\x00\x88\x02\x00\x00\x4b\x03\x20\x03\x00\x00\x64\x00\x38\x02\x47\x2d\x08\x03\x96\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x2c\xdc\xff\xcd\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x04\x00\x00\xfc\x05\x00\x00\x00\x00\x00\x00\x00\x00\x94\x04\x00\x00\x83\x01\x6a\x04\x00\x00\x00\x00\x00\x00\x56\x00\x26\x00\x00\x00\x00\x00\x61\x00\x00\x00\x00\x00\x00\x00\x1a\x02\x00\x00\x00\x00\x00\x00\x60\x00\x13\x02\xdb\xff\x00\x00\x00\x00\x00\x00\x00\x00\xf3\xff\x00\x00\x00\x00\x00\x00\x00\x00\xe7\xff\x00\x00\x00\x00\x00\x00\x9c\x00\xe8\x05\x00\x00\x00\x00\x00\x00\xd7\x08\x81\x02\x00\x00\x00\x00\x00\x00\x52\x03\x00\x00\x00\x00\x75\x02\xf5\x01\x00\x00\xaa\xff\x5d\x02\x5c\x02\x00\x00\x00\x00\x66\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\x5a\x20\x00\x00\x00\x00\x00\x00\x1f\x29\x00\x00\x20\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7a\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x01\x00\x00\x00\x00\xd2\x28\x00\x00\xac\x00\x00\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbc\x28\x00\x00\x00\x00\xc0\x1f\x73\x1f\x28\x22\x00\x00\x00\x00\x00\x00\x26\x02\x00\x00\x78\x2d\x00\x00\x00\x00\x30\x27\x00\x00\xdb\x01\x21\x02\x00\x00\x00\x00\x00\x00\xa7\x02\x00\x00\x00\x00\x00\x00\x23\x02\x00\x00\x00\x00\x00\x00\xd2\x04\x40\x00\x28\x00\x00\x00\x00\x00\x30\x03\x1d\x00\x00\x00\xbe\x04\xe8\x08\x00\x00\x00\x00\xdc\x04\x72\x00\x00\x00\x00\x00\x0f\x04\x4c\x06\x00\x00\xf5\x02\x00\x00\x00\x00\xb7\x01\x00\x00\x64\x24\x17\x24\x00\x00\x00\x00\x00\x00\x00\x00\xe2\x03\x71\x00\x6f\x00\xff\x00\x00\x00\x82\x02\x07\x03\x00\x00\x98\x01\x01\x24\x9f\x00\x00\x00\xe3\x14\xb1\x02\x00\x00\x00\x00\x3f\x03\x00\x00\x00\x00\x00\x00\x00\x00\xd0\xff\x00\x00\x83\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf7\xff\x00\x00\x00\x00\x00\x00\xe7\x02\x00\x00\x00\x00\x52\x02\x00\x00\x37\x02\x00\x00\x7a\x00\x00\x00\x9f\x01\x00\x00\x00\x00\x16\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x01\x00\x00\x00\x00\x00\x00\xb4\x23\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x05\x00\x00\x8f\x02\x00\x00\x00\x00\x00\x00\x83\x01\x00\x00\xcf\x02\xb3\xff\x00\x00\x00\x00\x1e\x02\x00\x00\xf1\x00\x00\x00\x44\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbc\x00\x38\x04\xf0\x00\x00\x00\x00\x00\x38\x06\x00\x00\xbe\x04\x00\x00\x54\x01\xf2\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\xb0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x02\x00\x00\x4d\x02\x00\x00\xeb\x00\x00\x00\x00\x00\x00\x00\x9e\x23\x51\x23\x3b\x23\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x01\xcb\x00\x00\x00\x0d\x20\xee\x22\x46\x27\x00\x00\x6f\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x50\x02\x00\x00\x00\x00\xbc\x01\x00\x00\x00\x00\xbe\x04\x00\x00\x00\x00\xbe\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xde\x05\x00\x00\x00\x00\x00\x00\x00\x00\x88\x00\x00\x00\x00\x00\xfe\x06\x60\x01\x00\x00\x00\x00\xc0\x05\x27\x03\x00\x00\xe0\xff\x36\x05\x00\x00\x00\x00\x54\x00\x00\x00\x11\x00\x00\x00\x11\x01\x00\x00\x00\x00\x00\x00\x52\x01\x00\x00\x8b\x00\x00\x00\x49\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\x00\xdd\x00\x00\x00\x00\x00\x22\x05\x00\x00\x00\x00\x81\x00\x7c\x00\x93\x02\x00\x00\x00\x00\x00\x00\xb1\x00\x44\x04\x86\x05\x4a\x05\x0e\x05\x5a\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x02\xd8\x22\x00\x00\x00\x00\x8b\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfa\x04\x00\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\xef\xff\x00\x00\xb4\x00\x62\x02\x96\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x28\x00\x00\x00\x00\x00\x00\xd8\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfd\xff\x00\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x00\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#--happyDefActions :: HappyAddr-happyDefActions = HappyA# "\xa1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\xfd\xa1\xfd\x00\x00\xe5\xff\xed\xff\x00\x00\x00\x00\x02\xfe\xc2\xfe\xc0\xfe\xba\xfe\xb9\xfe\xb7\xfe\xb5\xfe\xb0\xfe\xa7\xfe\xa2\xfe\x9a\xfe\x96\xfe\x88\xfe\x00\x00\x00\x00\x93\xfe\x94\xfe\x95\xfe\xf2\xfd\xed\xfd\xc7\xfd\xd4\xfd\xeb\xfd\xe8\xfd\xbf\xfd\x92\xfe\xd2\xfd\xd3\xfd\xc1\xfd\xc0\xfd\xbd\xfd\xbe\xfd\xab\xfd\xa9\xfd\xaa\xfd\xa8\xfd\xa7\xfd\xa6\xfd\xa5\xfd\xa4\xfd\xa3\xfd\xa2\xfd\x00\x00\x00\x00\x00\x00\x8c\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\xfe\x00\x00\x00\x00\x00\x00\x00\x00\xa1\xfd\x00\x00\x00\x00\x7d\xfe\x00\x00\x00\x00\x6b\xfe\xce\xfd\xc6\xfd\xc5\xfd\xc4\xfd\xcd\xfd\xcc\xfd\xcb\xfd\xca\xfd\xc9\xfd\xc8\xfd\xd1\xfd\x00\x00\xa1\xfd\xc2\xfd\xc3\xfd\xcf\xfd\x00\x00\xa1\xfd\xa1\xfd\x00\x00\xa1\xfd\xd0\xfd\x00\x00\x00\x00\x00\x00\x43\xff\x29\xff\x4a\xff\x40\xff\x3e\xff\x37\xff\x00\x00\x2c\xff\x00\x00\x00\x00\x99\xfd\x30\xff\x3d\xff\x9a\xfd\x00\x00\x00\x00\x00\x00\x98\xfd\x97\xfd\x96\xfd\x22\xff\x85\xff\xad\xff\x00\x00\x00\x00\x90\xff\x86\xff\x7f\xff\x84\xff\x97\xff\xb9\xfe\x00\x00\x00\x00\x00\x00\x8f\xff\x00\x00\x00\x00\xab\xff\xaa\xff\xa9\xff\x00\x00\xa1\xfd\x8e\xff\x00\x00\x60\xff\x60\xff\x00\x00\x60\xff\x62\xff\x54\xff\x54\xff\x00\x00\x0d\xfe\x00\x00\x00\x00\xc2\xfe\x00\x00\xe5\xff\xf4\xff\xf2\xff\xa1\xfd\x00\x00\xe5\xff\x00\x00\x00\x00\x00\x00\x4f\xff\x50\xff\xf1\xfd\xea\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x55\xff\x00\x00\x52\xff\x00\x00\x00\x00\x63\xff\x60\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\xff\x00\x00\x00\x00\x76\xff\x00\x00\xd9\xff\xd9\xff\xd8\xfe\x00\x00\x8b\xff\x00\x00\x1c\xff\x00\x00\x00\x00\x00\x00\x00\x00\xda\xfd\xd9\xfd\x00\x00\xde\xfd\xd5\xfd\xbc\xfd\xe4\xfd\xb9\xfd\xb8\xfd\xb5\xfd\xba\xfd\xac\xfd\xbb\xfd\x00\x00\x00\x00\xb2\xfd\xd6\xfd\x00\x00\xb4\xfd\xb3\xfd\xb1\xfd\xe8\xfe\x00\x00\x00\x00\xac\xff\x00\x00\x00\x00\x34\xff\x25\xff\x00\x00\x00\x00\x32\xff\x7b\xfe\x25\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\xff\x00\x00\x00\x00\x2a\xff\x41\xff\x00\x00\x2d\xff\x00\x00\x94\xfd\x93\xfd\x00\x00\x00\x00\x00\x00\x28\xff\x00\x00\x00\x00\x00\x00\x01\xfe\x07\xfe\x07\xfe\x00\x00\x9f\xfe\x00\x00\xa8\xfe\x04\xfe\xae\xfe\xa9\xfe\x00\x00\xac\xfe\x00\x00\x35\xfe\x66\xfe\x62\xfe\x65\xfe\x64\xfe\x63\xfe\x5e\xfe\x5d\xfe\x5c\xfe\x5b\xfe\x5a\xfe\x59\xfe\x58\xfe\x57\xfe\x56\xfe\x55\xfe\x54\xfe\x53\xfe\x52\xfe\x51\xfe\x60\xfe\x5f\xfe\x50\xfe\x4f\xfe\x4e\xfe\x4d\xfe\x4c\xfe\x4b\xfe\x4a\xfe\x49\xfe\x48\xfe\x47\xfe\x46\xfe\x45\xfe\x44\xfe\x43\xfe\x42\xfe\x41\xfe\x40\xfe\x3f\xfe\x3e\xfe\x3d\xfe\x3c\xfe\x3b\xfe\x3a\xfe\x61\xfe\x39\xfe\x38\xfe\x37\xfe\x7e\xfe\x7f\xfe\x00\x00\x00\x00\x00\x00\x81\xfe\x80\xfe\x00\x00\x00\x00\x00\x00\x00\x00\xb9\xfe\x00\x00\x00\x00\x73\xfe\x00\x00\x0c\xfe\xaa\xfe\x9b\xfe\x00\x00\xa0\xfe\x7a\xfe\x31\xfe\x00\x00\x30\xfe\xd8\xfd\xd7\xfd\x00\x00\xe2\xfd\xb7\xfd\xb6\xfd\xb0\xfd\xf6\xfd\x00\x00\xae\xfd\xaf\xfd\xad\xfd\x00\x00\xf4\xfd\x7a\xfe\x00\x00\x00\x00\x00\x00\xde\xfd\x00\x00\xb6\xfd\xb0\xfd\xf7\xfd\xae\xfd\xb4\xfd\xaf\xfd\xad\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\xfe\xbf\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd9\xff\x00\x00\x00\x00\xf7\xff\xe5\xff\xf6\xff\x00\x00\xd9\xff\xe8\xff\xda\xff\x00\x00\xed\xff\xef\xff\x9f\xfd\xa0\xfd\xbb\xfe\xbc\xfe\xbd\xfe\xbe\xfe\xc1\xfe\xb8\xfe\xb6\xfe\x00\x00\xff\xfd\xfd\xfd\x99\xfe\xfc\xfd\x03\xfe\x9c\xfe\x9d\xfe\x00\x00\x45\xff\xec\xfd\xe7\xfd\x8b\xfe\x00\x00\x90\xfe\x91\xfe\x00\x00\xf5\xfd\x7c\xfe\x00\x00\x00\x00\xf3\xfd\x00\x00\x00\x00\x79\xfe\x00\x00\x8d\xfe\x00\x00\x2f\xfe\x00\x00\xa1\xfe\x00\x00\x00\x00\x8a\xfe\x00\x00\x86\xfe\x85\xfe\x84\xfe\x83\xfe\x00\x00\xd9\xff\xa4\xff\x00\x00\x00\x00\x32\xfe\x6e\xfe\x00\x00\x68\xfe\x6c\xfe\xad\xfe\x6a\xfe\x00\x00\xa1\xfd\x00\x00\xaf\xfe\x00\x00\x9e\xfe\x00\x00\x00\x00\x05\xfe\x07\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x46\xff\x47\xff\x00\x00\x48\xff\x49\xff\x44\xff\x35\xff\x2e\xff\x2f\xff\x33\xff\x00\x00\x3c\xff\x39\xff\x00\x00\x31\xff\x3b\xff\x00\x00\x3a\xff\x23\xff\x21\xff\x00\x00\x00\x00\xae\xff\xdc\xfd\xdb\xfd\xa7\xff\xe0\xfd\xe6\xfd\x00\x00\xe8\xfe\xf4\xfe\x15\xff\x00\x00\x0a\xff\x81\xff\x00\x00\x00\x00\x72\xff\xca\xfe\xc6\xfe\xc4\xfe\x00\x00\x00\x00\xca\xfe\x68\xff\x71\xff\x70\xff\x6f\xff\x6e\xff\x6d\xff\x6c\xff\x00\x00\xe4\xfe\x1e\xff\xe8\xfe\x00\x00\x8c\xff\x45\xff\x8d\xff\x99\xff\x9a\xff\xa1\xfd\x89\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\xff\xe8\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5d\xff\x64\xff\x94\xff\x56\xff\x93\xff\x00\x00\x53\xff\x92\xff\x00\x00\x4d\xff\x00\x00\x00\x00\x91\xff\x4c\xff\xe2\xff\x9e\xfd\x9d\xfd\x00\x00\x35\xfe\xe7\xff\xd9\xff\xd9\xff\x00\x00\xdc\xff\x00\x00\x32\xfe\x00\x00\xd7\xff\x00\x00\x00\x00\xf0\xfd\xe9\xfd\x4e\xff\x51\xff\x57\xff\x65\xff\x00\x00\x00\x00\x00\x00\x00\x00\x5f\xff\x00\x00\x79\xff\x77\xff\x7a\xff\x7d\xff\x7e\xff\xa3\xff\x46\xff\xa2\xff\x00\x00\x74\xff\x82\xff\x75\xff\x83\xff\xd9\xff\x87\xff\xc8\xfe\xd9\xff\xf9\xfd\x95\xfe\xdb\xff\xd9\xff\xd9\xff\x98\xff\x9e\xff\x00\x00\x1b\xff\x19\xff\x9b\xff\xa1\xfd\x95\xff\x00\x00\xef\xfd\x00\x00\x00\x00\x00\x00\x6b\xff\x6a\xff\x69\xff\xcc\xfe\xa1\xfd\x1a\xfe\x00\x00\x1c\xfe\x00\x00\xa1\xfd\xc7\xfe\xc5\xfe\xcd\xfe\x00\x00\x00\x00\xe3\xfd\x10\xff\x0e\xff\x00\x00\x22\xff\xe7\xfe\xee\xfe\xed\xfe\x00\x00\xea\xfe\xeb\xfe\xf4\xfe\xa1\xfd\xa0\xff\x00\x00\xf4\xfe\x15\xff\x00\x00\x00\x00\x00\x00\x2b\xff\x00\x00\x24\xff\x00\x00\x26\xff\x95\xfd\x27\xff\x00\x00\xa5\xfe\xa6\xfe\x0a\xfe\x08\xfe\x09\xfe\x07\xfe\x0b\xfe\xb1\xfe\xb3\xfe\x00\x00\xab\xfe\xd9\xff\xd9\xff\x73\xfe\x00\x00\x00\x00\x33\xfe\x00\x00\x36\xfe\x00\x00\xd2\xfd\xbd\xfd\xce\xfd\xc6\xfd\xc5\xfd\xc4\xfd\xcd\xfd\xcc\xfd\xcb\xfd\xca\xfd\xc9\xfd\xc8\xfd\xd1\xfd\xc2\xfd\xc3\xfd\xcf\xfd\xd0\xfd\x67\xfe\xda\xff\xa6\xff\x00\x00\x00\x00\x74\xfe\xb4\xfe\x2b\xfe\x27\xfe\x25\xfe\x24\xfe\x23\xfe\x00\x00\x2d\xfe\x7a\xfe\x29\xfe\x2a\xfe\xdd\xfd\xe1\xfd\x78\xfe\x71\xfe\x72\xfe\x8e\xfe\x8f\xfe\x00\x00\x75\xfe\x97\xfe\x00\x00\x98\xfe\x00\x00\xee\xff\xeb\xff\x00\x00\x00\x00\xea\xff\xec\xff\xe9\xff\x00\xfe\xfe\xfd\x77\xfe\x76\xfe\x2e\xfe\x22\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x89\xfe\x82\xfe\xa5\xff\x6b\xfe\x6f\xfe\x00\x00\x6d\xfe\x69\xfe\x00\x00\x00\x00\x00\x00\xae\xfe\x06\xfe\x00\x00\x38\xff\x00\x00\xa8\xff\xdf\xfd\xe5\xfd\xf4\xfe\x9d\xff\xf3\xfe\xef\xfe\x00\x00\xd9\xff\xd9\xff\x9f\xff\x00\x00\x00\x00\x00\x00\xfd\xfe\x05\xff\x00\x00\x0c\xff\x09\xff\x04\xff\x00\x00\x00\x00\x30\xff\x00\x00\x00\x00\x00\x00\x0a\xff\x80\xff\x73\xff\x00\x00\x19\xfe\x00\x00\x00\x00\xcb\xfe\x96\xff\x00\x00\x00\x00\x00\x00\xd9\xff\xd9\xff\x1e\xff\x1f\xff\x1e\xff\xd6\xfe\x00\x00\x00\x00\x00\x00\xda\xff\xfb\xfd\x00\x00\xda\xff\x8a\xff\xa1\xff\x00\x00\x7c\xff\x5e\xff\x00\x00\x00\x00\x5b\xff\x59\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\xff\xd3\xff\xf3\xff\x00\x00\xe0\xff\xd9\xff\xc9\xff\xde\xff\xc6\xff\xe1\xff\xc4\xff\x00\x00\xda\xff\xdd\xff\x6b\xfe\xf0\xff\x00\x00\xd3\xff\xd1\xff\xd0\xff\x9b\xfd\xcf\xff\xd4\xff\x00\x00\xe6\xff\xe4\xff\xe3\xff\x00\x00\x00\x00\x5a\xff\x5c\xff\x7b\xff\x78\xff\x88\xff\xfa\xfd\x00\x00\xf8\xfd\xd9\xfe\xda\xfe\x00\x00\xd1\xfe\xd9\xff\xd4\xfe\xd2\xfe\xd3\xfe\xc8\xfe\x8f\xff\x00\x00\x00\x00\x18\xff\x1a\xff\xe2\xfe\x00\x00\x00\x00\x66\xff\x00\x00\xee\xfd\xc3\xfe\x1b\xfe\x0f\xff\x00\x00\xfc\xfe\x3f\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x01\xff\x00\x00\x00\x00\x05\xff\x0d\xff\x00\x00\x00\x00\x00\x00\x0b\xff\xec\xfe\xe9\xfe\x00\x00\x00\x00\x00\x00\xf0\xfe\x00\x00\xf2\xfe\x9c\xff\x00\x00\x00\x00\x00\x00\x17\xfe\x18\xfe\xd9\xff\x14\xfe\x00\x00\x34\xfe\xac\xfe\x1d\xfe\x28\xfe\x26\xfe\x00\x00\x00\x00\x00\x00\x2c\xfe\x21\xfe\x1f\xfe\x20\xfe\x00\x00\xca\xfe\x11\xfe\x0f\xfe\x00\x00\x00\x00\xda\xff\x16\xfe\x00\x00\x00\x00\x20\xff\xf1\xfe\x16\xff\x17\xff\xd9\xff\x12\xff\x00\x00\x00\x00\x00\x00\x03\xff\x00\x00\x00\x00\xff\xfe\x42\xff\x08\xff\x00\x00\x00\x00\xf9\xfe\x07\xff\x2f\xff\x00\x00\x67\xff\xe5\xfe\xe6\xfe\xdf\xfe\xd9\xff\xe0\xfe\xde\xfe\x00\x00\x00\x00\x1d\xff\x00\x00\x00\x00\xda\xff\xd7\xfe\xe8\xfe\x00\x00\x61\xff\xcb\xff\x00\x00\x00\x00\xd4\xff\xd5\xff\x00\x00\xca\xff\xdf\xff\xc7\xff\xc2\xff\xc5\xff\x00\x00\xc3\xff\x00\x00\xd2\xff\xd6\xff\x00\x00\xb1\xff\xb0\xff\xaf\xff\xcd\xff\x00\x00\x00\x00\xf4\xfe\x15\xff\xd5\xfe\xc9\xfe\x00\x00\x00\x00\x43\xff\xe8\xfe\xe8\xfe\xda\xff\xe3\xfe\xfb\xfe\x06\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xda\xff\x14\xff\x00\x00\xb2\xfe\x15\xfe\x12\xfe\x00\x00\x10\xfe\x13\xfe\x00\x00\x00\x00\x1e\xfe\x00\x00\x00\x00\x00\x00\x13\xff\x11\xff\x02\xff\xfe\xfe\xf7\xfe\xf8\xfe\x00\x00\x00\x00\xfa\xfe\xe1\xfe\xdb\xfe\xdd\xfe\x00\x00\xd0\xfe\xf4\xfe\xcf\xfe\x58\xff\xce\xff\xcc\xff\x00\x00\x00\x00\xc0\xff\xbe\xff\x00\x00\xf1\xff\xb2\xff\xce\xfe\xdc\xfe\x00\x00\xf6\xfe\x00\x00\x0e\xfe\x70\xfe\xa4\xfe\x00\x00\xc1\xff\xc8\xff\xbf\xff\x00\x00\xbb\xff\xd3\xff\xf5\xfe\x00\x00\xd3\xff\xb8\xff\xb7\xff\x9c\xfd\xb6\xff\x00\x00\x00\x00\xd4\xff\xbc\xff\xb9\xff\xbd\xff\x00\x00\xb4\xff\x00\x00\xb5\xff\xb3\xff"#--happyCheck :: HappyAddr-happyCheck = HappyA# "\xff\xff\x00\x00\x04\x00\x04\x00\x02\x00\x04\x00\x04\x00\x0b\x00\x11\x00\x12\x00\x13\x00\x3b\x00\x3c\x00\x07\x00\x11\x00\x20\x00\x24\x00\x36\x00\x0d\x00\x0e\x00\x2d\x00\x6b\x00\x07\x00\x3b\x00\x3c\x00\x32\x00\x1d\x00\x1e\x00\x90\x00\x0d\x00\x0e\x00\x16\x00\x2d\x00\xa6\x00\x2d\x00\xae\x00\x13\x00\x32\x00\x50\x00\x32\x00\x0d\x00\x0e\x00\x1c\x00\x08\x00\x09\x00\x0d\x00\x0e\x00\x36\x00\x0c\x00\x1c\x00\x00\x00\x0d\x00\x0e\x00\x0d\x00\x0e\x00\x2d\x00\x1a\x00\x22\x00\x2a\x00\xae\x00\x32\x00\x5d\x00\x68\x00\xae\x00\x46\x00\x1c\x00\x48\x00\x1c\x00\x16\x00\x2a\x00\x11\x00\x24\x00\x25\x00\x1c\x00\xd5\x00\x5b\x00\x2e\x00\x0d\x00\x0e\x00\x6f\x00\xd5\x00\x1f\x00\xc6\x00\x2f\x00\x31\x00\x32\x00\x33\x00\x1c\x00\x3a\x00\xcd\x00\xce\x00\xcf\x00\x09\x00\xd1\x00\x0b\x00\xd3\x00\x32\x00\x33\x00\xd5\x00\x0d\x00\x0e\x00\x4e\x00\xd5\x00\x77\x00\x1f\x00\x20\x00\x70\x00\x09\x00\x1e\x00\xd7\x00\x54\x00\x66\x00\x53\x00\x57\x00\x58\x00\x1f\x00\x20\x00\xcb\x00\xcc\x00\x70\x00\x14\x00\x15\x00\x27\x00\xc8\x00\x0d\x00\x0e\x00\x0d\x00\x0e\x00\x45\x00\x46\x00\x5a\x00\x48\x00\x49\x00\x21\x00\x24\x00\x23\x00\x4d\x00\x25\x00\x26\x00\x27\x00\x28\x00\xda\x00\xdb\x00\x15\x00\x2c\x00\x8a\x00\x2e\x00\x2f\x00\xb9\x00\x0d\x00\x0e\x00\x89\x00\xc8\x00\xc9\x00\x5a\x00\x21\x00\x76\x00\x23\x00\x89\x00\x25\x00\x26\x00\x27\x00\x28\x00\xc8\x00\xc8\x00\xc9\x00\x2c\x00\xb8\x00\x2e\x00\x2f\x00\xbe\x00\xbc\x00\xa7\x00\xc1\x00\x89\x00\xc3\x00\x89\x00\xba\x00\xb9\x00\x33\x00\xbd\x00\xb8\x00\x89\x00\xc8\x00\xc9\x00\xbc\x00\xce\x00\xcc\x00\xd5\x00\xd1\x00\xc7\x00\xc8\x00\xc9\x00\xc8\x00\xcb\x00\xcc\x00\xb4\x00\xc8\x00\xc9\x00\xa7\x00\xd5\x00\xcc\x00\xd5\x00\xba\x00\x76\x00\x19\x00\xbd\x00\xb4\x00\xd9\x00\xd5\x00\xcc\x00\xd5\x00\xd5\x00\xd8\x00\xd5\x00\xd5\x00\xc7\x00\xc8\x00\xc9\x00\xcc\x00\xcb\x00\xcc\x00\x7a\x00\xd5\x00\x71\x00\x69\x00\x71\x00\x22\x00\x33\x00\xc8\x00\x82\x00\x83\x00\x84\x00\x85\x00\xd9\x00\x6f\x00\x88\x00\x89\x00\x8a\x00\x33\x00\x6f\x00\x8d\x00\x8e\x00\x8f\x00\x7a\x00\x40\x00\x41\x00\xda\x00\xdb\x00\x95\x00\x39\x00\x5d\x00\x82\x00\x83\x00\x84\x00\x85\x00\x17\x00\xb8\x00\x88\x00\x89\x00\x8a\x00\xbc\x00\xb8\x00\x8d\x00\x8e\x00\x8f\x00\xbc\x00\x22\x00\xb8\x00\x6f\x00\x22\x00\x95\x00\xbc\x00\xc8\x00\xc9\x00\x05\x00\x06\x00\xcc\x00\xc8\x00\xc9\x00\x67\x00\xb9\x00\xcc\x00\xb7\x00\xc8\x00\xc9\x00\xba\x00\xbb\x00\xcc\x00\xbd\x00\x66\x00\x67\x00\x16\x00\x39\x00\xd8\x00\x5d\x00\xc8\x00\xc8\x00\x1c\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xb7\x00\x22\x00\xc1\x00\xba\x00\xbb\x00\x59\x00\xbd\x00\xd4\x00\x6f\x00\xba\x00\xda\x00\xdb\x00\x2d\x00\x69\x00\x17\x00\xce\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xc7\x00\xc8\x00\xc9\x00\x22\x00\x21\x00\x17\x00\x23\x00\xd4\x00\x25\x00\x26\x00\x27\x00\x28\x00\x54\x00\xb8\x00\xb6\x00\x2c\x00\x58\x00\x2e\x00\x2f\x00\xbb\x00\x5b\x00\x5c\x00\x28\x00\x08\x00\xb3\x00\x0a\x00\x21\x00\xd7\x00\x23\x00\xc8\x00\xc9\x00\xba\x00\x27\x00\x28\x00\xca\x00\x18\x00\xba\x00\x2c\x00\xb8\x00\x2e\x00\x2f\x00\x29\x00\xbc\x00\x87\x00\xc7\x00\xc8\x00\xc9\x00\xba\x00\xac\x00\xc7\x00\xc8\x00\xc9\x00\x25\x00\x7b\x00\xc8\x00\xc9\x00\x87\x00\x95\x00\xcc\x00\x97\x00\xc7\x00\xc8\x00\xc9\x00\xd6\x00\x31\x00\x32\x00\x33\x00\x43\x00\x44\x00\x45\x00\x95\x00\x47\x00\x97\x00\x49\x00\x4a\x00\x4b\x00\x19\x00\x03\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x08\x00\x09\x00\x47\x00\x22\x00\x49\x00\x4a\x00\x4b\x00\x05\x00\x06\x00\x42\x00\x43\x00\x7a\x00\x45\x00\x95\x00\x47\x00\x97\x00\x49\x00\x4a\x00\x4b\x00\x82\x00\x83\x00\x84\x00\x85\x00\x17\x00\x16\x00\x88\x00\x89\x00\x8a\x00\x19\x00\x5c\x00\x8d\x00\x8e\x00\x8f\x00\x7a\x00\x22\x00\xcc\x00\xbd\x00\x22\x00\x95\x00\x05\x00\x06\x00\x82\x00\x83\x00\x84\x00\x85\x00\xc8\x00\xd6\x00\x88\x00\x89\x00\x8a\x00\xcb\x00\xcc\x00\x8d\x00\x8e\x00\x8f\x00\x21\x00\x16\x00\x23\x00\x40\x00\x41\x00\x95\x00\x27\x00\x28\x00\xda\x00\xdb\x00\x19\x00\x2c\x00\xd7\x00\x2e\x00\x2f\x00\x22\x00\x17\x00\xb7\x00\x17\x00\x22\x00\xba\x00\xbb\x00\x29\x00\xbd\x00\x43\x00\x44\x00\x45\x00\x22\x00\x47\x00\x22\x00\x49\x00\x4a\x00\x4b\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xb7\x00\x22\x00\x26\x00\xba\x00\xbb\x00\x26\x00\xbd\x00\xd4\x00\x7c\x00\x2d\x00\x2b\x00\xbb\x00\x4a\x00\x4b\x00\x17\x00\x01\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x08\x00\x09\x00\xc8\x00\x22\x00\xca\x00\xcb\x00\xcc\x00\xd4\x00\x19\x00\x47\x00\xbd\x00\x49\x00\x4a\x00\x4b\x00\xbb\x00\xc8\x00\x22\x00\x22\x00\xcb\x00\xcc\x00\xda\x00\xdb\x00\x28\x00\x19\x00\xcb\x00\xcc\x00\x11\x00\xc8\x00\x7a\x00\xca\x00\xcb\x00\xcc\x00\x22\x00\xda\x00\xdb\x00\x22\x00\x82\x00\x83\x00\x84\x00\x85\x00\x96\x00\x28\x00\x88\x00\x89\x00\x8a\x00\xda\x00\xdb\x00\x8d\x00\x8e\x00\x8f\x00\x21\x00\xce\x00\x23\x00\xbf\x00\xd1\x00\x95\x00\xc2\x00\x90\x00\xc4\x00\x92\x00\xc6\x00\x2c\x00\xb8\x00\x2e\x00\x2f\x00\x17\x00\xbc\x00\xcd\x00\xce\x00\xcf\x00\x90\x00\xd1\x00\x92\x00\xd3\x00\x21\x00\x90\x00\x23\x00\x92\x00\xc8\x00\xc9\x00\x0d\x00\x0e\x00\xcc\x00\xbb\x00\x2b\x00\x2c\x00\x1e\x00\x2e\x00\x2f\x00\xb7\x00\x22\x00\x16\x00\xba\x00\xbb\x00\x01\x00\xbd\x00\xc8\x00\xd6\x00\xca\x00\xcb\x00\xcc\x00\x08\x00\x09\x00\x0d\x00\x0e\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x1a\x00\x1b\x00\x1c\x00\xda\x00\xdb\x00\xc8\x00\xc6\x00\xd4\x00\xcb\x00\xcc\x00\x42\x00\x43\x00\xd1\x00\xcd\x00\xce\x00\x47\x00\x69\x00\x49\x00\x4a\x00\x4b\x00\x72\x00\x73\x00\x74\x00\xda\x00\xdb\x00\x1e\x00\xba\x00\xc8\x00\x7a\x00\x22\x00\xcb\x00\xcc\x00\x0d\x00\x0e\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x84\x00\xc7\x00\xc8\x00\xc9\x00\x88\x00\x86\x00\x8a\x00\xda\x00\xdb\x00\x8d\x00\x8e\x00\x8f\x00\xc8\x00\xc9\x00\x7a\x00\xd6\x00\xcc\x00\x95\x00\x21\x00\x59\x00\x23\x00\x98\x00\x99\x00\x9a\x00\x84\x00\x25\x00\x96\x00\x27\x00\x88\x00\x2c\x00\x8a\x00\x2e\x00\x2f\x00\x8d\x00\x8e\x00\x8f\x00\x69\x00\x31\x00\x32\x00\x33\x00\xd5\x00\x95\x00\xcf\x00\x2b\x00\xd1\x00\x2d\x00\xd3\x00\x08\x00\x21\x00\x52\x00\x23\x00\xb7\x00\x54\x00\x55\x00\xba\x00\xbb\x00\x27\x00\xbd\x00\x29\x00\x2c\x00\x69\x00\x2e\x00\x2f\x00\x98\x00\x99\x00\x9a\x00\xd1\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xb5\x00\xb6\x00\xb7\x00\x25\x00\xd5\x00\xba\x00\xbb\x00\xd4\x00\xbd\x00\x0d\x00\x0e\x00\xba\x00\xaa\x00\xab\x00\xac\x00\x31\x00\x32\x00\x33\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xc7\x00\xc8\x00\xc9\x00\x73\x00\x74\x00\x08\x00\x09\x00\xd4\x00\x03\x00\xc8\x00\x7a\x00\xd6\x00\xcb\x00\xcc\x00\x42\x00\x43\x00\x6c\x00\x6d\x00\x6e\x00\x47\x00\x84\x00\x49\x00\x4a\x00\x4b\x00\x88\x00\x0a\x00\x8a\x00\xda\x00\xdb\x00\x8d\x00\x8e\x00\x8f\x00\x9b\x00\xbe\x00\x25\x00\x38\x00\xc1\x00\x95\x00\xc3\x00\x3a\x00\x7a\x00\x0c\x00\x0d\x00\x0e\x00\x28\x00\x6f\x00\x31\x00\x32\x00\x33\x00\xce\x00\x84\x00\x2f\x00\xd1\x00\x27\x00\x88\x00\x29\x00\x8a\x00\xb2\x00\xb3\x00\x8d\x00\x8e\x00\x8f\x00\x43\x00\xd6\x00\x45\x00\xba\x00\x47\x00\x95\x00\x49\x00\x4a\x00\x4b\x00\xb7\x00\xc8\x00\xc9\x00\xba\x00\xbb\x00\x28\x00\xbd\x00\xc7\x00\xc8\x00\xc9\x00\x5f\x00\x60\x00\x2f\x00\x0c\x00\x0d\x00\x0e\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xd5\x00\x27\x00\x47\x00\x29\x00\x49\x00\x4a\x00\x4b\x00\xd4\x00\xb7\x00\x6f\x00\xc6\x00\xba\x00\xbb\x00\xd6\x00\xbd\x00\x30\x00\x31\x00\xcd\x00\xce\x00\xcf\x00\x27\x00\xd1\x00\x29\x00\xd3\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x43\x00\x70\x00\x45\x00\xd4\x00\x47\x00\x7b\x00\x49\x00\x4a\x00\x4b\x00\x84\x00\x35\x00\x4e\x00\x4f\x00\x88\x00\x27\x00\x8a\x00\x29\x00\x7f\x00\x8d\x00\x8e\x00\x8f\x00\xc8\x00\xba\x00\x7b\x00\xcb\x00\xcc\x00\x95\x00\x6d\x00\x6e\x00\x78\x00\x79\x00\x7a\x00\x5e\x00\x5f\x00\x60\x00\xc7\x00\xc8\x00\xc9\x00\x59\x00\xda\x00\xdb\x00\x84\x00\x7d\x00\x7e\x00\x7f\x00\x88\x00\x27\x00\x8a\x00\x29\x00\x69\x00\x8d\x00\x8e\x00\x8f\x00\xd6\x00\x27\x00\xbb\x00\x29\x00\x27\x00\x95\x00\x29\x00\xb7\x00\x6d\x00\x6e\x00\xba\x00\xbb\x00\x27\x00\xbd\x00\x29\x00\xc8\x00\xba\x00\xca\x00\xcb\x00\xcc\x00\x6c\x00\x6d\x00\x6e\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xc7\x00\xc8\x00\xc9\x00\xd6\x00\xda\x00\xdb\x00\x27\x00\xd4\x00\x29\x00\x27\x00\xb7\x00\x29\x00\xd6\x00\xba\x00\xbb\x00\xc8\x00\xbd\x00\xc8\x00\xcb\x00\xcc\x00\xcb\x00\xcc\x00\x6c\x00\x6d\x00\x6e\x00\xb0\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x90\x00\xda\x00\xdb\x00\xda\x00\xdb\x00\x9b\x00\xbb\x00\xd4\x00\x86\x00\x30\x00\x31\x00\xbf\x00\x34\x00\x27\x00\xc2\x00\x29\x00\xc4\x00\x34\x00\xc6\x00\xc8\x00\x56\x00\xca\x00\xcb\x00\xcc\x00\x75\x00\xcd\x00\xce\x00\xcf\x00\x43\x00\xd1\x00\x45\x00\xd3\x00\x47\x00\x39\x00\x49\x00\x4a\x00\x4b\x00\xda\x00\xdb\x00\x4e\x00\x4f\x00\xcc\x00\x30\x00\x31\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x42\x00\x43\x00\x7d\x00\x7e\x00\x7f\x00\x47\x00\xd7\x00\x49\x00\x4a\x00\x4b\x00\x98\x00\x99\x00\x9a\x00\x43\x00\x27\x00\x45\x00\x29\x00\x47\x00\x39\x00\x49\x00\x4a\x00\x4b\x00\x42\x00\x43\x00\x4e\x00\x4f\x00\x27\x00\x47\x00\x29\x00\x49\x00\x4a\x00\x4b\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\xc7\x00\xc8\x00\xc9\x00\x4d\x00\xcb\x00\xcc\x00\x98\x00\x99\x00\x9a\x00\x43\x00\x27\x00\x45\x00\x29\x00\x47\x00\x39\x00\x49\x00\x4a\x00\x4b\x00\x3f\x00\x40\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xc7\x00\xc8\x00\xc9\x00\x39\x00\xcb\x00\xcc\x00\x27\x00\x43\x00\x29\x00\x45\x00\x27\x00\x47\x00\x29\x00\x49\x00\x4a\x00\x4b\x00\x0d\x00\x0e\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x22\x00\x46\x00\x47\x00\x52\x00\x49\x00\x4a\x00\x4b\x00\x51\x00\x52\x00\x53\x00\x43\x00\xbb\x00\x45\x00\x29\x00\x47\x00\x2b\x00\x49\x00\x4a\x00\x4b\x00\x96\x00\x4d\x00\x4e\x00\x4f\x00\x2b\x00\xc8\x00\x2d\x00\xca\x00\xcb\x00\xcc\x00\x86\x00\x87\x00\x88\x00\x65\x00\xd5\x00\x90\x00\xc8\x00\x0d\x00\x0e\x00\xcb\x00\xcc\x00\x0f\x00\x10\x00\xda\x00\xdb\x00\xbb\x00\xc8\x00\x16\x00\x68\x00\xcb\x00\xcc\x00\x29\x00\x90\x00\x2b\x00\xda\x00\xdb\x00\x99\x00\x9a\x00\xc8\x00\x17\x00\xca\x00\xcb\x00\xcc\x00\x90\x00\xda\x00\xdb\x00\x0d\x00\x0e\x00\xc8\x00\x05\x00\x06\x00\xcb\x00\xcc\x00\x0d\x00\x0e\x00\x43\x00\xda\x00\xdb\x00\xbb\x00\x47\x00\x17\x00\x49\x00\x4a\x00\x4b\x00\x0d\x00\x0e\x00\xda\x00\xdb\x00\xb8\x00\xc6\x00\x22\x00\xc8\x00\xbc\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\x17\x00\xd1\x00\x16\x00\xd3\x00\x5a\x00\xc8\x00\xc9\x00\xbb\x00\x4a\x00\xcc\x00\xda\x00\xdb\x00\x08\x00\x09\x00\x37\x00\x38\x00\x05\x00\x06\x00\xc6\x00\x32\x00\xc8\x00\x89\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\x60\x00\xd1\x00\x89\x00\xd3\x00\xbb\x00\xc8\x00\x05\x00\x06\x00\xcb\x00\xcc\x00\xda\x00\xdb\x00\x49\x00\x4a\x00\x4b\x00\x28\x00\x29\x00\xc8\x00\x0c\x00\xca\x00\xcb\x00\xcc\x00\x4a\x00\xda\x00\xdb\x00\x1c\x00\x43\x00\x28\x00\x45\x00\x29\x00\x47\x00\x29\x00\x49\x00\x4a\x00\x4b\x00\xda\x00\xdb\x00\x4e\x00\x4f\x00\x78\x00\x51\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x17\x00\x43\x00\x60\x00\x45\x00\x17\x00\x47\x00\x0f\x00\x49\x00\x4a\x00\x4b\x00\x05\x00\x06\x00\x4e\x00\x4f\x00\x1c\x00\x51\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x6a\x00\x43\x00\x17\x00\x45\x00\x64\x00\x47\x00\x29\x00\x49\x00\x4a\x00\x4b\x00\x1d\x00\x4d\x00\x4e\x00\x4f\x00\x4a\x00\x4b\x00\xc8\x00\x4a\x00\x4b\x00\xcb\x00\xcc\x00\x43\x00\x32\x00\x45\x00\x28\x00\x47\x00\x32\x00\x49\x00\x4a\x00\x4b\x00\x27\x00\x4d\x00\x4e\x00\x4f\x00\xda\x00\xdb\x00\x03\x00\x04\x00\x83\x00\x84\x00\x1c\x00\x43\x00\x2b\x00\x45\x00\x47\x00\x47\x00\x78\x00\x49\x00\x4a\x00\x4b\x00\x77\x00\x4d\x00\x4e\x00\x4f\x00\x22\x00\x28\x00\x29\x00\x62\x00\x90\x00\x05\x00\x06\x00\x43\x00\x0c\x00\x45\x00\x17\x00\x47\x00\x17\x00\x49\x00\x4a\x00\x4b\x00\x22\x00\x4d\x00\x4e\x00\x4f\x00\xc8\x00\x1e\x00\x89\x00\xcb\x00\xcc\x00\x89\x00\x05\x00\xbb\x00\x17\x00\x1e\x00\x32\x00\x29\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x16\x00\x28\x00\xda\x00\xdb\x00\xc8\x00\x22\x00\xca\x00\xcb\x00\xcc\x00\x17\x00\x1c\x00\xbb\x00\x25\x00\x79\x00\xc8\x00\x89\x00\x7e\x00\xcb\x00\xcc\x00\x78\x00\x29\x00\x1c\x00\xda\x00\xdb\x00\xc8\x00\x89\x00\xca\x00\xcb\x00\xcc\x00\x1e\x00\x89\x00\xbb\x00\xda\x00\xdb\x00\xc8\x00\x89\x00\x28\x00\xcb\x00\xcc\x00\x17\x00\x69\x00\x64\x00\xda\x00\xdb\x00\xc8\x00\x89\x00\xca\x00\xcb\x00\xcc\x00\x1d\x00\x1d\x00\xbb\x00\xda\x00\xdb\x00\x17\x00\x60\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x31\x00\x1c\x00\xda\x00\xdb\x00\xc8\x00\x1e\x00\xca\x00\xcb\x00\xcc\x00\x05\x00\x2b\x00\xbb\x00\x5b\x00\x22\x00\x41\x00\x2b\x00\x1c\x00\x29\x00\x4c\x00\x0c\x00\x22\x00\x17\x00\xda\x00\xdb\x00\xc8\x00\x28\x00\xca\x00\xcb\x00\xcc\x00\x43\x00\x24\x00\xbb\x00\x24\x00\x47\x00\x78\x00\x49\x00\x4a\x00\x4b\x00\x1d\x00\x60\x00\x60\x00\x2c\x00\xda\x00\xdb\x00\xc8\x00\x2d\x00\xca\x00\xcb\x00\xcc\x00\x43\x00\x1d\x00\x45\x00\x1d\x00\x47\x00\x2b\x00\x49\x00\x4a\x00\x4b\x00\x28\x00\x4d\x00\x4e\x00\x4f\x00\xda\x00\xdb\x00\xc8\x00\x1d\x00\x29\x00\xcb\x00\xcc\x00\x43\x00\x21\x00\x45\x00\x22\x00\x47\x00\x22\x00\x49\x00\x4a\x00\x4b\x00\x89\x00\x4d\x00\x4e\x00\x4f\x00\xda\x00\xdb\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x0f\x00\x43\x00\x0f\x00\x45\x00\x16\x00\x47\x00\x46\x00\x49\x00\x4a\x00\x4b\x00\x1e\x00\x4d\x00\x4e\x00\x4f\x00\x4c\x00\x17\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x17\x00\x43\x00\x0f\x00\x45\x00\x28\x00\x47\x00\x64\x00\x49\x00\x4a\x00\x4b\x00\x0c\x00\x4d\x00\x4e\x00\x4f\x00\x21\x00\x28\x00\xc8\x00\x29\x00\x89\x00\xcb\x00\xcc\x00\x43\x00\x89\x00\x45\x00\x89\x00\x47\x00\x1e\x00\x49\x00\x4a\x00\x4b\x00\x1e\x00\x4d\x00\x4e\x00\x4f\x00\xda\x00\xdb\x00\x1d\x00\x22\x00\x17\x00\x28\x00\x78\x00\x43\x00\x78\x00\x45\x00\x2b\x00\x47\x00\x78\x00\x49\x00\x4a\x00\x4b\x00\x64\x00\x4d\x00\x4e\x00\x4f\x00\xc8\x00\x24\x00\x78\x00\xcb\x00\xcc\x00\x60\x00\x22\x00\xbb\x00\x27\x00\x24\x00\x1c\x00\x1e\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x75\x00\x1d\x00\xda\x00\xdb\x00\xc8\x00\x47\x00\xca\x00\xcb\x00\xcc\x00\x17\x00\x24\x00\xbb\x00\x24\x00\x89\x00\x1b\x00\x22\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x29\x00\x05\x00\xda\x00\xdb\x00\xc8\x00\x1c\x00\xca\x00\xcb\x00\xcc\x00\x17\x00\x17\x00\xbb\x00\x17\x00\x17\x00\xc8\x00\x17\x00\x17\x00\xcb\x00\xcc\x00\x22\x00\x17\x00\x17\x00\xda\x00\xdb\x00\xc8\x00\x2d\x00\xca\x00\xcb\x00\xcc\x00\x41\x00\x17\x00\xbb\x00\xda\x00\xdb\x00\xc8\x00\x41\x00\x21\x00\xcb\x00\xcc\x00\x41\x00\x27\x00\x21\x00\xda\x00\xdb\x00\xc8\x00\x4c\x00\xca\x00\xcb\x00\xcc\x00\x2b\x00\x2d\x00\xbb\x00\xda\x00\xdb\x00\x72\x00\x1c\x00\x69\x00\x89\x00\x89\x00\x0c\x00\x17\x00\x17\x00\xda\x00\xdb\x00\xc8\x00\x22\x00\xca\x00\xcb\x00\xcc\x00\x43\x00\x78\x00\xbb\x00\x17\x00\x47\x00\x17\x00\x49\x00\x4a\x00\x4b\x00\x21\x00\x2b\x00\x69\x00\x29\x00\xda\x00\xdb\x00\xc8\x00\x20\x00\xca\x00\xcb\x00\xcc\x00\x43\x00\x28\x00\x45\x00\x22\x00\x47\x00\x0f\x00\x49\x00\x4a\x00\x4b\x00\x05\x00\x4d\x00\x4e\x00\x4f\x00\xda\x00\xdb\x00\xc8\x00\x89\x00\x70\x00\xcb\x00\xcc\x00\x43\x00\x1d\x00\x45\x00\x0f\x00\x47\x00\x8a\x00\x49\x00\x4a\x00\x4b\x00\x20\x00\x4d\x00\x4e\x00\x4f\x00\xda\x00\xdb\x00\xc8\x00\x1d\x00\x6d\x00\xcb\x00\xcc\x00\x43\x00\x16\x00\x45\x00\x63\x00\x47\x00\x28\x00\x49\x00\x4a\x00\x4b\x00\x8a\x00\x4d\x00\x4e\x00\x4f\x00\xda\x00\xdb\x00\x0c\x00\x0f\x00\x0f\x00\x8a\x00\x0f\x00\x43\x00\x1d\x00\x45\x00\x1d\x00\x47\x00\x1d\x00\x49\x00\x4a\x00\x4b\x00\x8a\x00\x4d\x00\x4e\x00\x4f\x00\x2c\x00\x1d\x00\x2c\x00\x00\x00\x8a\x00\x70\x00\xff\xff\x43\x00\xff\xff\x45\x00\xff\xff\x47\x00\xff\xff\x49\x00\x4a\x00\x4b\x00\xff\xff\xff\xff\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x43\x00\xff\xff\x45\x00\xff\xff\x47\x00\xff\xff\x49\x00\x4a\x00\x4b\x00\xff\xff\xff\xff\x4e\x00\x4f\x00\xc8\x00\xff\xff\xff\xff\xcb\x00\xcc\x00\xff\xff\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xda\x00\xdb\x00\xc8\x00\xff\xff\xca\x00\xcb\x00\xcc\x00\xff\xff\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xda\x00\xdb\x00\xc8\x00\xff\xff\xca\x00\xcb\x00\xcc\x00\xff\xff\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xda\x00\xdb\x00\xc8\x00\xff\xff\xca\x00\xcb\x00\xcc\x00\xff\xff\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xda\x00\xdb\x00\xc8\x00\xff\xff\xca\x00\xcb\x00\xcc\x00\xff\xff\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xda\x00\xdb\x00\xc8\x00\xff\xff\xca\x00\xcb\x00\xcc\x00\x43\x00\xff\xff\xbb\x00\xff\xff\x47\x00\xff\xff\x49\x00\x4a\x00\x4b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xda\x00\xdb\x00\xc8\x00\xff\xff\xca\x00\xcb\x00\xcc\x00\x43\x00\xff\xff\x45\x00\xff\xff\x47\x00\xff\xff\x49\x00\x4a\x00\x4b\x00\xff\xff\xff\xff\x4e\x00\x4f\x00\xda\x00\xdb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x43\x00\xff\xff\x45\x00\xff\xff\x47\x00\xff\xff\x49\x00\x4a\x00\x4b\x00\xff\xff\xff\xff\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x43\x00\xff\xff\x45\x00\xff\xff\x47\x00\xff\xff\x49\x00\x4a\x00\x4b\x00\xff\xff\xff\xff\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x43\x00\xff\xff\x45\x00\xff\xff\x47\x00\xff\xff\x49\x00\x4a\x00\x4b\x00\xff\xff\xff\xff\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x43\x00\xff\xff\x45\x00\xff\xff\x47\x00\xff\xff\x49\x00\x4a\x00\x4b\x00\xff\xff\xff\xff\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x43\x00\xff\xff\x45\x00\xff\xff\x47\x00\xff\xff\x49\x00\x4a\x00\x4b\x00\xff\xff\xff\xff\x4e\x00\x4f\x00\xc8\x00\xff\xff\xff\xff\xcb\x00\xcc\x00\xff\xff\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xda\x00\xdb\x00\xc8\x00\xff\xff\xca\x00\xcb\x00\xcc\x00\xff\xff\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xda\x00\xdb\x00\xc8\x00\xff\xff\xca\x00\xcb\x00\xcc\x00\xff\xff\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xda\x00\xdb\x00\xc8\x00\xff\xff\xca\x00\xcb\x00\xcc\x00\xff\xff\x43\x00\xbb\x00\x45\x00\xff\xff\x47\x00\xff\xff\x49\x00\x4a\x00\x4b\x00\xff\xff\xff\xff\xff\xff\xda\x00\xdb\x00\xc8\x00\xff\xff\xca\x00\xcb\x00\xcc\x00\xff\xff\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xda\x00\xdb\x00\xc8\x00\xff\xff\xca\x00\xcb\x00\xcc\x00\xff\xff\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xda\x00\xdb\x00\xc8\x00\xff\xff\xca\x00\xcb\x00\xcc\x00\x43\x00\xff\xff\x45\x00\xff\xff\x47\x00\xff\xff\x49\x00\x4a\x00\x4b\x00\xff\xff\xff\xff\x4e\x00\x4f\x00\xda\x00\xdb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x43\x00\xff\xff\x45\x00\xff\xff\x47\x00\xff\xff\x49\x00\x4a\x00\x4b\x00\xff\xff\xff\xff\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x43\x00\xff\xff\x45\x00\xff\xff\x47\x00\xff\xff\x49\x00\x4a\x00\x4b\x00\xff\xff\xff\xff\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x43\x00\xbb\x00\x45\x00\xff\xff\x47\x00\xff\xff\x49\x00\x4a\x00\x4b\x00\xff\xff\xff\xff\x4e\x00\x4f\x00\xff\xff\xc8\x00\xff\xff\xca\x00\xcb\x00\xcc\x00\xff\xff\x46\x00\x47\x00\xff\xff\x49\x00\x4a\x00\x4b\x00\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\xda\x00\xdb\x00\xff\xff\xff\xff\xff\xff\x46\x00\x47\x00\xff\xff\x49\x00\x4a\x00\x4b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\x63\x00\xff\xff\x65\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\x63\x00\xff\xff\x65\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\xc8\x00\xff\xff\xca\x00\xcb\x00\xcc\x00\xff\xff\xff\xff\xbb\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\x3e\x00\x3f\x00\x40\x00\xff\xff\xda\x00\xdb\x00\xc8\x00\xff\xff\xca\x00\xcb\x00\xcc\x00\x8a\x00\xff\xff\xbb\x00\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\xda\x00\xdb\x00\xc8\x00\xff\xff\xca\x00\xcb\x00\xcc\x00\xff\xff\xff\xff\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xba\x00\xff\xff\xff\xff\xbd\x00\xda\x00\xdb\x00\xc8\x00\xff\xff\xca\x00\xcb\x00\xcc\x00\xff\xff\xbd\x00\xc7\x00\xc8\x00\xc9\x00\xb7\x00\xcb\x00\xcc\x00\xba\x00\xbb\x00\xff\xff\xbd\x00\xc8\x00\xda\x00\xdb\x00\xcb\x00\xcc\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xff\xff\xff\xff\xc8\x00\xda\x00\xdb\x00\xcb\x00\xcc\x00\xd4\x00\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xff\xff\xbc\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xda\x00\xdb\x00\xff\xff\xff\xff\xff\xff\xc2\x00\xc8\x00\xc9\x00\xff\xff\xc6\x00\xcc\x00\xc8\x00\xff\xff\xff\xff\xcb\x00\xcc\x00\xcd\x00\xce\x00\xff\xff\xb8\x00\xff\xff\xff\xff\xff\xff\xbc\x00\xb8\x00\xff\xff\xff\xff\xff\xff\xbc\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xff\xff\xff\xff\xc8\x00\xc9\x00\xff\xff\xff\xff\xcc\x00\xc8\x00\xc9\x00\xff\xff\xff\xff\xcc\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\x1c\x00\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x67\x00\x68\x00\xff\xff\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\xff\xff\x71\x00\xff\xff\x73\x00\xff\xff\xff\xff\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\x88\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xbf\x00\x18\x00\xff\xff\xc2\x00\xff\xff\xc4\x00\xff\xff\xc6\x00\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xcd\x00\xce\x00\xcf\x00\xff\xff\xd1\x00\x2a\x00\xd3\x00\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x67\x00\x68\x00\xff\xff\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\xff\xff\x71\x00\xff\xff\x73\x00\xff\xff\xff\xff\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\x88\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x67\x00\xff\xff\xff\xff\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x01\x00\x71\x00\xff\xff\x73\x00\x05\x00\x06\x00\x76\x00\xff\xff\x09\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\xff\xff\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x16\x00\xff\xff\x18\x00\x88\x00\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\x20\x00\xff\xff\xff\xff\xff\xff\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\xff\xff\x32\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\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x16\x00\xff\xff\x18\x00\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\x20\x00\x66\x00\x09\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x16\x00\xff\xff\x18\x00\x32\x00\xff\xff\x79\x00\xff\xff\xff\xff\x01\x00\x02\x00\x20\x00\x66\x00\x05\x00\x06\x00\x24\x00\xff\xff\xff\xff\x85\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x32\x00\x16\x00\x79\x00\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x64\x00\xff\xff\x66\x00\x05\x00\x06\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x79\x00\x18\x00\xff\xff\x01\x00\xff\xff\xff\xff\x66\x00\x05\x00\x06\x00\x20\x00\xff\xff\xff\xff\x85\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x16\x00\x79\x00\x18\x00\x32\x00\x01\x00\xff\xff\xff\xff\xff\xff\x63\x00\x64\x00\x20\x00\x66\x00\xff\xff\x85\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x00\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\x32\x00\xff\xff\x79\x00\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\x66\x00\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\x79\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x20\x00\x66\x00\xff\xff\xff\xff\x50\x00\xff\xff\xff\xff\x85\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\x32\x00\xff\xff\x79\x00\xff\xff\xff\xff\xff\xff\x24\x00\x25\x00\x66\x00\x27\x00\x28\x00\xff\xff\xff\xff\xff\xff\x85\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\x79\x00\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x66\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\xff\xff\x79\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\x00\x23\x00\x24\x00\x25\x00\x85\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\x08\x00\x09\x00\x0a\x00\x0b\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x67\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\xff\xff\x6e\x00\x6f\x00\xff\xff\xff\xff\xff\xff\x73\x00\xff\xff\x31\x00\x32\x00\x33\x00\xff\xff\x79\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\x08\x00\x09\x00\x0a\x00\x0b\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x67\x00\x24\x00\x25\x00\xff\xff\x27\x00\xff\xff\xff\xff\x6e\x00\x6f\x00\xff\xff\xff\xff\xff\xff\x73\x00\xff\xff\x31\x00\x32\x00\x33\x00\xff\xff\x79\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x67\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\xff\xff\xff\xff\xff\xff\x73\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x79\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\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\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x67\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\xff\xff\xff\xff\xff\xff\x73\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x79\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\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\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x67\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\xff\xff\xff\xff\xff\xff\x73\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x79\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x80\x00\x81\x00\x82\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\x1c\x00\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x67\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\xff\xff\xff\xff\xff\xff\xff\xff\x79\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x80\x00\x81\x00\x82\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\x1c\x00\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x67\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\xff\xff\xff\xff\xff\xff\x73\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x79\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x80\x00\x81\x00\x82\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xbf\x00\x18\x00\xff\xff\xc2\x00\xff\xff\xc4\x00\xff\xff\xc6\x00\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xcd\x00\xce\x00\xcf\x00\xff\xff\xd1\x00\x2a\x00\xd3\x00\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x67\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\xff\xff\xff\xff\xff\xff\x73\x00\xff\xff\x75\x00\xff\xff\xff\xff\xff\xff\x79\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x80\x00\x81\x00\x82\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x67\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\xff\xff\xff\xff\xff\xff\x73\x00\x74\x00\xff\xff\xff\xff\xff\xff\xff\xff\x79\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x80\x00\x81\x00\x82\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x67\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\xff\xff\xff\xff\xff\xff\x73\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x79\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x80\x00\x81\x00\x82\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x67\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\xff\xff\xff\xff\xff\xff\x73\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x79\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x80\x00\x81\x00\x82\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\xff\xff\xff\xff\xff\xff\x73\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x79\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x80\x00\x81\x00\x82\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x67\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\xff\xff\xff\xff\xff\xff\x73\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x79\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x80\x00\x81\x00\x82\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x67\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\xff\xff\xff\xff\xff\xff\x73\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x79\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x80\x00\x81\x00\x82\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x67\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\xff\xff\xff\xff\xff\xff\x73\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x79\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x80\x00\x81\x00\x82\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\x1c\x00\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\x66\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\x79\x00\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\x6a\x00\x6b\x00\x6c\x00\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\x6a\x00\x6b\x00\x6c\x00\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\x1c\x00\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\x64\x00\x88\x00\x66\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\x6f\x00\xff\xff\x71\x00\x95\x00\xff\xff\xff\xff\xff\xff\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xb7\x00\x18\x00\xff\xff\xba\x00\xbb\x00\x1c\x00\xbd\x00\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xd4\x00\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\x01\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\x6a\x00\x6b\x00\x6c\x00\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\x66\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\x79\x00\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\xff\xff\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\x6f\x00\xff\xff\x71\x00\x95\x00\xff\xff\xff\xff\xff\xff\x76\x00\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xb7\x00\x18\x00\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xd4\x00\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\x6a\x00\x6b\x00\x6c\x00\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\x79\x00\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\x2f\x00\x01\x00\xff\xff\x32\x00\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\x16\x00\x46\x00\x18\x00\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x79\x00\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x2f\x00\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\x38\x00\xff\xff\x66\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x6d\x00\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\x79\x00\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x79\x00\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\x2f\x00\x05\x00\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\x08\x00\x09\x00\x0a\x00\x0b\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\x64\x00\x22\x00\x66\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\x29\x00\xff\xff\x2b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\xff\xff\xff\xff\x79\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\x08\x00\x09\x00\x0a\x00\x0b\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x17\x00\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\x00\xff\xff\xff\xff\x25\x00\x22\x00\x27\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\x2d\x00\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\xff\xff\x31\x00\x32\x00\x33\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\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\x08\x00\x09\x00\x64\x00\x0b\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x79\x00\x20\x00\xff\xff\x05\x00\x06\x00\x24\x00\x08\x00\x09\x00\x27\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\x2f\x00\x30\x00\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\x24\x00\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\x2f\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x66\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x79\x00\x16\x00\xff\xff\x18\x00\x19\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\xff\xff\x66\x00\x20\x00\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x00\xff\xff\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\x79\x00\xff\xff\x22\x00\xff\xff\xff\xff\x25\x00\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x16\x00\x17\x00\x18\x00\x31\x00\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\x01\x00\x20\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\x79\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x79\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6d\x00\xff\xff\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\x79\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x64\x00\xff\xff\x66\x00\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\x79\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x20\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\xff\xff\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\x79\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\x64\x00\xff\xff\x66\x00\x01\x00\x20\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x79\x00\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x66\x00\xff\xff\x20\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\x16\x00\x17\x00\xff\xff\x79\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x26\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x79\x00\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x16\x00\x17\x00\xff\xff\xff\xff\xff\xff\xff\xff\x79\x00\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\x26\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\x79\x00\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x16\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x30\x00\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\x79\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x66\x00\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\x79\x00\xff\xff\x70\x00\xff\xff\x16\x00\xff\xff\x01\x00\xff\xff\x76\x00\x50\x00\x05\x00\x79\x00\x1e\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x26\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x79\x00\xff\xff\x01\x00\x02\x00\xff\xff\x66\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x16\x00\x79\x00\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x16\x00\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\x79\x00\x63\x00\x64\x00\xff\xff\x66\x00\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x76\x00\xff\xff\xff\xff\x79\x00\x1e\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\x63\x00\x64\x00\xff\xff\x66\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\x79\x00\x63\x00\x64\x00\x20\x00\x66\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\x79\x00\x63\x00\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\x79\x00\x20\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\x26\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\x79\x00\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x16\x00\xff\xff\x18\x00\x01\x00\x02\x00\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\x20\x00\x66\x00\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x79\x00\xff\xff\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\x79\x00\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x16\x00\xff\xff\x18\x00\x01\x00\x02\x00\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\x20\x00\x66\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x79\x00\xff\xff\x63\x00\x64\x00\xff\xff\x66\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\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\x79\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x16\x00\xff\xff\x18\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x66\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x79\x00\xff\xff\x63\x00\x64\x00\xff\xff\x66\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\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\x79\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x16\x00\xff\xff\x18\x00\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\xff\xff\xff\xff\x20\x00\x66\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x16\x00\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\x79\x00\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x79\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x16\x00\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x16\x00\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\x79\x00\x05\x00\x63\x00\x64\x00\xff\xff\x66\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x16\x00\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x79\x00\x63\x00\x64\x00\xff\xff\x66\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x16\x00\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x79\x00\x63\x00\x64\x00\xff\xff\x66\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x16\x00\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x79\x00\x63\x00\x64\x00\xff\xff\x66\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x16\x00\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\x79\x00\x05\x00\x63\x00\x64\x00\xff\xff\x66\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x79\x00\x63\x00\x64\x00\xff\xff\x66\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x79\x00\x63\x00\x64\x00\xff\xff\x66\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x79\x00\x63\x00\x64\x00\xff\xff\x66\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x79\x00\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x16\x00\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\xff\xff\x79\x00\x63\x00\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\x25\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x79\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\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\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\x79\x00\x88\x00\x89\x00\x8a\x00\x66\x00\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x79\x00\xff\xff\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xff\xff\xa5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xad\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd4\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa1\x00\xa2\x00\xa3\x00\xff\xff\xa5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xad\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd4\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\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\xa2\x00\xa3\x00\xff\xff\xa5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xad\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd4\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\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\xa4\x00\xa5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xad\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd4\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\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\xad\x00\xff\xff\xaf\x00\xff\xff\xb1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd4\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\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\xa4\x00\xa5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xad\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd4\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\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\xad\x00\xff\xff\xaf\x00\xff\xff\xb1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd4\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\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\xa4\x00\xa5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xad\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd4\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\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\xad\x00\xff\xff\xaf\x00\xff\xff\xb1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd4\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\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\xad\x00\xff\xff\xaf\x00\xff\xff\xb1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd4\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\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\xa5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xad\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd4\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\xad\x00\xff\xff\xff\xff\xff\xff\xb1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xd4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd4\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xd4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd4\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xd4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd4\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xd4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd4\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xd4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd4\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xd4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd4\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xd4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd4\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xd4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd4\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xd4\x00\xff\xff\xc0\x00\xff\xff\xc2\x00\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\x91\x00\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9e\x00\x9f\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\x91\x00\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xc0\x00\xff\xff\xc2\x00\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xff\xff\xd0\x00\xff\xff\xd2\x00\xd3\x00\xd4\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xc0\x00\xff\xff\xc2\x00\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xff\xff\xd0\x00\xff\xff\xd2\x00\xd3\x00\xd4\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\x91\x00\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\x91\x00\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xc0\x00\xff\xff\xc2\x00\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xff\xff\xd0\x00\xff\xff\xd2\x00\xd3\x00\xd4\x00\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xc0\x00\xff\xff\xc2\x00\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xff\xff\xd0\x00\xff\xff\xd2\x00\xd3\x00\xd4\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\x91\x00\xff\xff\xff\xff\xff\xff\x95\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\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xc0\x00\xff\xff\xc2\x00\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xff\xff\xd0\x00\xff\xff\xd2\x00\xd3\x00\xd4\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xa8\x00\xa9\x00\xff\xff\x95\x00\xff\xff\xad\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xa9\x00\xff\xff\xff\xff\xff\xff\xad\x00\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xd4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd4\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\x95\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xd4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd4\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\x93\x00\xff\xff\x95\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xad\x00\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xd4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd4\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xd4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd4\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xd4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd4\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xd4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd4\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xd4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd4\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xd4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd4\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xd4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd4\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xd4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd4\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xd4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd4\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xd4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd4\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xd4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd4\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xd4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd4\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xd4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xd4\x00\xff\xff\x95\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\x8c\x00\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xd4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xd4\x00\x95\x00\xff\xff\xff\xff\x98\x00\x99\x00\x9a\x00\xff\xff\x9c\x00\x9d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xff\xff\xff\xff\x98\x00\x99\x00\x9a\x00\xff\xff\x9c\x00\x9d\x00\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xd4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xb7\x00\xff\xff\xd4\x00\xba\x00\xbb\x00\x95\x00\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xd4\x00\xff\xff\xff\xff\x95\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xd4\x00\xba\x00\xbb\x00\xff\xff\xbd\x00\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xd4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xb7\x00\xff\xff\xd4\x00\xba\x00\xbb\x00\x95\x00\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xd4\x00\xff\xff\xff\xff\x95\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xd4\x00\xba\x00\xbb\x00\xff\xff\xbd\x00\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xd4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xb7\x00\xff\xff\xd4\x00\xba\x00\xbb\x00\x95\x00\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xd4\x00\xff\xff\xff\xff\x95\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb7\x00\xff\xff\xd4\x00\xba\x00\xbb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xb7\x00\xff\xff\xff\xff\xba\x00\xbb\x00\xff\xff\xbd\x00\xd4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd4\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"#--happyTable :: HappyAddr-happyTable = HappyA# "\x00\x00\x0c\x00\x09\x00\x0b\x00\x9d\x00\x09\x00\x9e\x00\x3f\x02\x59\x03\x5a\x03\x5b\x03\x66\x03\x42\x03\xed\x02\x45\x04\x34\x04\xf3\x01\x2a\x03\x8f\x01\x00\x03\xc1\x00\x0d\x03\x8d\x01\x41\x03\x42\x03\x26\x03\x46\x04\x47\x04\xf2\x00\x8f\x01\x1b\x02\xba\xff\xc1\x00\xae\x02\xc1\x00\x06\x01\xf1\x03\x29\x03\xcb\x00\xc2\x00\x8f\x01\x1b\x02\x6a\x02\xd8\x00\xd9\x00\x8f\x01\x00\x03\x73\x02\x2a\x02\x6a\x02\x94\x01\x8f\x01\x33\x03\x8f\x01\x98\x03\xc1\x00\x79\x01\xbd\x01\x1c\x02\x0c\x01\x0d\x01\xfa\x03\xcc\x00\x0f\x01\xa3\x00\x2e\x02\xa4\x00\x30\x02\x91\x02\x1e\x02\x4c\x04\xfa\x01\xde\x00\x30\x02\x07\x01\xad\x03\x7a\x01\x8f\x01\x98\x03\xfb\x03\xaf\x02\x95\x01\xf3\x00\x2b\x02\xe1\x00\xe2\x00\xe3\x00\xce\x01\x7b\x01\xd2\x00\xd3\x00\xf4\x00\xd9\x00\xd5\x00\xdb\x00\xd6\x00\x92\x02\x93\x02\x07\x01\x8f\x01\x33\x03\x00\x03\x07\x01\xae\x03\x51\x04\xf4\x03\xa5\x00\xd9\x00\x4f\x04\x3e\x04\x6e\x02\x43\x04\xef\x01\x6f\x02\x70\x02\xf3\x03\xf4\x03\x0e\x03\x25\x00\xa5\x00\x4e\x03\x4f\x03\xdf\x00\x6f\x00\x8f\x01\x7c\x03\x8f\x01\x7c\x03\xcf\x01\x4a\x00\x99\x03\x4b\x00\x4c\x00\x7a\x00\x8c\x03\x7b\x00\xd0\x01\x50\x03\xc4\x01\xc5\x01\x7d\x00\xdb\x03\x72\x00\xe9\x03\x7e\x00\xf5\xff\x7f\x00\x80\x00\x74\x02\x03\x04\x04\x04\xed\x02\x21\x00\x43\x03\x9a\x03\x7a\x00\x34\x03\x7b\x00\xe9\x02\xea\x03\xc4\x01\xc5\x01\x7d\x00\x75\x02\x21\x00\x43\x03\x7e\x00\xf5\x03\x7f\x00\x80\x00\xf4\x01\xf6\x03\x01\x03\xf5\x01\x2f\x02\xf6\x01\x31\x02\x5c\x03\x74\x02\x01\x02\x5d\x03\x48\x04\x34\x02\x21\x00\xa9\x00\x49\x04\xf7\x01\xaa\x00\xc3\x00\xf8\x01\x20\x00\x21\x00\x22\x00\x75\x02\x24\x00\x25\x00\x1d\x02\x21\x00\xa9\x00\x02\x03\xc3\x00\xaa\x00\xc3\x00\x5c\x03\x35\x03\x31\x04\x5d\x03\x1f\x02\x5e\x03\x40\x02\x8e\x01\x0a\x00\x0a\x00\x4a\x04\x0a\x00\x0a\x00\x20\x00\x21\x00\x22\x00\x8e\x01\x24\x00\x25\x00\x81\x00\xc3\x00\x7d\x03\x35\x04\x7e\x03\xf8\x02\xcc\x03\x6f\x00\x82\x00\x10\x00\x83\x00\x12\x00\x5e\x03\x25\x04\x13\x00\x14\x00\x15\x00\xcc\x03\x26\x04\x16\x00\x17\x00\x18\x00\x81\x00\xa5\x00\x8c\x01\xf0\x01\x72\x00\x19\x00\xf9\x02\x97\x02\x82\x00\x10\x00\x83\x00\x12\x00\x56\x04\xf5\x03\x13\x00\x14\x00\x15\x00\xf6\x03\x48\x04\x16\x00\x17\x00\x18\x00\x49\x04\x2f\x04\xf5\x03\x98\x02\xbd\x01\x19\x00\xf6\x03\x21\x00\xa9\x00\x2c\x00\x2d\x00\xaa\x00\x21\x00\xa9\x00\x23\x04\x2c\x03\xaa\x00\x1c\x00\x21\x00\xa9\x00\x1d\x00\x1e\x00\xaa\x00\x1f\x00\xcd\x03\xce\x03\xc5\x03\xbe\x01\x4a\x04\xfb\x01\x75\x02\x6f\x00\x6a\x02\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\xf8\x02\x8a\x03\x1d\x00\x1e\x00\x29\x04\x1f\x00\x26\x00\xfc\x01\x02\x02\x31\x03\x72\x00\x1a\x04\x2a\x04\x2e\x04\xf7\x01\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x20\x00\x21\x00\x22\x00\x2f\x04\x7a\x00\xea\x01\x7b\x00\x26\x00\xc3\x01\xc4\x01\xc5\x01\x7d\x00\x6e\x02\x24\x03\x6b\x03\x7e\x00\x7b\x03\x7f\x00\x80\x00\x6c\x03\xc1\x03\xc2\x03\xeb\x01\xd8\x00\xee\x02\xda\x00\x7a\x00\x30\x04\x7b\x00\x21\x00\xa9\x00\x9e\x01\xfa\x02\x7d\x00\x23\x00\xee\x03\x02\x02\x7e\x00\xa7\x00\x7f\x00\x80\x00\x14\x02\xa8\x00\xb3\x03\x20\x00\x21\x00\x22\x00\x02\x02\x13\x04\x20\x00\x21\x00\x22\x00\xde\x00\x14\x04\x21\x00\xa9\x00\xca\x01\xcb\x01\xaa\x00\xcc\x01\x20\x00\x21\x00\x22\x00\xbf\x03\xe1\x00\xe2\x00\xe3\x00\x65\x00\x15\x02\x16\x02\xcb\x01\x67\x00\xcc\x01\x68\x00\x69\x00\x6a\x00\xb2\x01\x9f\x00\xea\x00\x6d\x00\x17\x02\xf1\x00\xa0\x00\xa1\x00\xc7\x03\xaf\x01\x68\x00\x69\x00\x6a\x00\x2c\x00\x2d\x00\xff\x03\x00\x04\x81\x00\x01\x04\xcb\x01\xbe\x00\xcc\x01\x68\x00\x69\x00\x6a\x00\x82\x00\x10\x00\x83\x00\x12\x00\xf2\x02\xc5\x03\x13\x00\x14\x00\x15\x00\xee\x00\x1b\x04\x16\x00\x17\x00\x18\x00\x81\x00\xef\x00\x9a\x02\xc3\x03\xef\x00\x19\x00\x2c\x00\x2d\x00\x82\x00\x10\x00\x83\x00\x12\x00\x6f\x00\xd3\x03\x13\x00\x14\x00\x15\x00\x24\x00\x25\x00\x16\x00\x17\x00\x18\x00\x7a\x00\x10\x03\x7b\x00\xa5\x00\xa6\x00\x19\x00\x7c\x00\x7d\x00\x9d\x02\x72\x00\xec\x01\x7e\x00\xe3\x03\x7f\x00\x80\x00\xf8\x02\xe1\x02\x1c\x00\xac\x01\xaf\x01\x1d\x00\x1e\x00\x29\x03\x1f\x00\x65\x00\xa4\x01\xa5\x01\xef\x00\xbe\x00\xef\x00\x68\x00\x69\x00\x6a\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\xb8\x01\xf3\x02\x1d\x00\x1e\x00\xb9\x01\x1f\x00\x26\x00\xcd\x00\xb1\x01\xba\x01\x6e\x00\x44\x01\x6a\x00\xe7\x01\x8b\x01\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x8a\x01\xa1\x00\x6f\x00\xaf\x01\x23\x00\x70\x00\x25\x00\x26\x00\xed\x01\x5c\x02\xc3\x03\x68\x00\x69\x00\x6a\x00\x6e\x00\x6f\x00\x87\x02\xee\x01\x70\x00\x25\x00\x71\x00\x72\x00\x09\x04\x6b\x01\x24\x00\x25\x00\xe5\x03\x6f\x00\x81\x00\x23\x00\x70\x00\x25\x00\xef\x00\x71\x00\x72\x00\x87\x02\x82\x00\x10\x00\x83\x00\x12\x00\xe8\x03\x88\x02\x13\x00\x14\x00\x15\x00\x71\x00\x72\x00\x16\x00\x17\x00\x18\x00\x7a\x00\x36\x02\x7b\x00\xce\x00\x37\x02\x19\x00\xcf\x00\xa9\x01\x39\x03\xf0\x02\xd1\x00\xd5\x03\xa7\x00\x7f\x00\x80\x00\xec\x03\xa8\x00\xd2\x00\xd3\x00\xd4\x00\xa9\x01\xd5\x00\xdf\x02\xd6\x00\x7a\x00\xa9\x01\x7b\x00\xaa\x01\x21\x00\xa9\x00\x0c\x04\x0d\x04\xaa\x00\x6e\x00\x63\x02\x64\x02\x07\x04\x7f\x00\x80\x00\x1c\x00\x08\x04\x53\x03\x1d\x00\x1e\x00\x89\x01\x1f\x00\x6f\x00\x6e\x03\x23\x00\x70\x00\x25\x00\x8a\x01\xa1\x00\xb9\x03\xba\x03\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x3f\x04\x40\x04\x41\x04\x71\x00\x72\x00\x6f\x00\xc6\x01\x26\x00\x70\x00\x25\x00\xd2\x03\x21\x02\x37\x02\xd2\x00\xd3\x00\xbe\x00\x9e\x03\x68\x00\x69\x00\x6a\x00\xd6\x03\xd7\x03\xd8\x03\x45\x01\x72\x00\xe6\x02\x25\x02\x6f\x00\x81\x00\xe7\x02\x70\x00\x25\x00\xde\x03\xdf\x03\xd8\x00\xd9\x00\xda\x00\xdb\x00\x65\x02\x20\x00\x21\x00\x22\x00\x13\x00\xa1\x03\x15\x00\x71\x00\x72\x00\x16\x00\x17\x00\x18\x00\x21\x00\x99\x02\x81\x00\xa2\x03\x9a\x02\x19\x00\x7a\x00\x0b\x03\x7b\x00\x18\x04\x14\x01\x15\x01\x65\x02\xde\x00\xa8\x03\xdf\x00\x13\x00\xd5\x03\x15\x00\x7f\x00\x80\x00\x16\x00\x17\x00\x18\x00\x0c\x03\xe1\x00\xe2\x00\xe3\x00\x10\x03\x19\x00\x70\x01\xb8\x03\xd5\x00\xb9\x03\xd6\x00\xd8\x00\x7a\x00\x15\x03\x7b\x00\x1c\x00\x79\x03\x7a\x03\x1d\x00\x1e\x00\x37\xfe\x1f\x00\x37\xfe\x6a\x03\x12\x03\x7f\x00\x80\x00\x2f\x04\x14\x01\x15\x01\x2b\x03\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x66\x02\x67\x02\x1c\x00\xde\x00\x2e\x03\x1d\x00\x68\x02\x26\x00\x1f\x00\x55\x03\x56\x03\x26\x02\xb4\x03\xb5\x03\xb6\x03\xe1\x00\xe2\x00\xe3\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x20\x00\x21\x00\x22\x00\x24\x04\xd8\x03\xd8\x00\xd9\x00\x26\x00\x4b\x03\x6f\x00\x81\x00\x4d\x03\x70\x00\x25\x00\xdc\x03\x21\x02\x9f\x03\x8e\x02\x8f\x02\xbe\x00\x65\x02\x68\x00\x69\x00\x6a\x00\x13\x00\x47\x02\x15\x00\x71\x00\x72\x00\x16\x00\x17\x00\x18\x00\x45\x02\xf4\x01\xde\x00\x4f\x02\xf5\x01\x19\x00\x08\x03\x50\x02\x81\x00\x42\x02\x8f\x01\x43\x02\x70\x03\x5d\x02\xe1\x00\xe2\x00\xe3\x00\xf7\x01\x65\x02\x71\x03\xf8\x01\x49\xfe\x13\x00\x49\xfe\x15\x00\x9c\x01\x9d\x01\x16\x00\x17\x00\x18\x00\x65\x00\x5f\x02\x22\x02\x9e\x01\xbe\x00\x19\x00\x68\x00\x69\x00\x6a\x00\x1c\x00\x21\x00\x65\x03\x1d\x00\x1e\x00\x70\x03\x1f\x00\x20\x00\x21\x00\x22\x00\x84\x03\x8b\x02\x71\x03\x44\x02\x8f\x01\x43\x02\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x6a\x02\x4b\xfe\xdd\x01\x4b\xfe\x68\x00\x69\x00\x6a\x00\x26\x00\x1c\x00\x6d\x02\xc6\x01\x1d\x00\x1e\x00\x60\x02\x1f\x00\x69\x03\x56\x02\xd2\x00\xd3\x00\x70\x01\x4c\xfe\xd5\x00\x4c\xfe\xd6\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x72\x03\x73\x03\x74\x03\x75\x03\x65\x00\x71\x02\x66\x00\x26\x00\x67\x00\x7c\x02\x68\x00\x69\x00\x6a\x00\x76\x03\x78\x02\x57\x02\x6d\x00\x13\x00\x53\xfe\x15\x00\x53\xfe\x84\x02\x16\x00\x17\x00\x18\x00\x6f\x00\x2b\x02\x85\x02\x70\x00\x25\x00\x19\x00\x96\x03\x8f\x02\xfc\x03\x74\x03\x75\x03\x89\x02\x8a\x02\x8b\x02\x20\x00\x21\x00\x22\x00\x93\x02\x71\x00\x72\x00\x76\x03\x03\x02\x04\x02\x05\x02\x13\x00\x54\xfe\x15\x00\x54\xfe\x95\x02\x16\x00\x17\x00\x18\x00\xa6\x02\x55\xfe\x6e\x00\x55\xfe\x56\xfe\x19\x00\x56\xfe\x1c\x00\x13\x03\x8f\x02\x1d\x00\x1e\x00\x57\xfe\x1f\x00\x57\xfe\x6f\x00\xb8\x00\x23\x00\x70\x00\x25\x00\x8d\x02\x8e\x02\x8f\x02\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x20\x00\x21\x00\x22\x00\xcc\x02\x71\x00\x72\x00\x58\xfe\x26\x00\x58\xfe\x59\xfe\x1c\x00\x59\xfe\x92\x01\x1d\x00\x1e\x00\x6f\x00\x1f\x00\x6f\x00\x70\x00\x25\x00\xb3\x01\x25\x00\x9f\x02\x8e\x02\x8f\x02\xa8\x02\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xec\x00\x71\x00\x72\x00\xdf\x01\x72\x00\xc8\x01\x6e\x00\x26\x00\xd1\x01\x40\x03\x56\x02\xce\x00\x09\x02\x5a\xfe\xcf\x00\x5a\xfe\xd0\x00\x10\x02\xd1\x00\x6f\x00\x11\x02\x23\x00\x70\x00\x25\x00\x19\x02\xd2\x00\xd3\x00\xd4\x00\x65\x00\xd5\x00\x66\x00\xd6\x00\x67\x00\x2c\x02\x68\x00\x69\x00\x6a\x00\x71\x00\x72\x00\x57\x02\x6d\x00\x34\x02\x55\x02\x56\x02\x44\x04\x87\x03\x69\x00\x6a\x00\x7f\x03\x21\x02\x08\x02\x04\x02\x05\x02\xbe\x00\x3a\x02\x68\x00\x69\x00\x6a\x00\x3e\x02\x14\x01\x15\x01\x65\x00\x5b\xfe\x66\x00\x5b\xfe\x67\x00\xb6\x00\x68\x00\x69\x00\x6a\x00\x20\x02\x21\x02\x57\x02\x6d\x00\x5c\xfe\xbe\x00\x5c\xfe\x68\x00\x69\x00\x6a\x00\xcf\x01\x4a\x00\xf1\x03\x4b\x00\x4c\x00\xb2\x01\x21\x00\x22\x00\xd0\x01\xb3\x01\x25\x00\x13\x01\x14\x01\x15\x01\x65\x00\x5d\xfe\x66\x00\x5d\xfe\x67\x00\xbb\x00\x68\x00\x69\x00\x6a\x00\x4d\x02\xb1\x00\xef\x00\x6d\x00\xf0\x00\xf1\x00\x0b\x02\x0c\x02\x0d\x02\x0e\x02\x0f\x02\x10\x02\x00\x02\x21\x00\x22\x00\xbc\x00\xb3\x01\x25\x00\x64\xfe\x65\x00\x64\xfe\x66\x00\x65\xfe\x67\x00\x65\xfe\x68\x00\x69\x00\x6a\x00\x37\x03\x38\x03\xef\x00\x6d\x00\xf0\x00\xf1\x00\xe5\x00\x16\x03\xca\x03\xe7\x00\x68\x00\x69\x00\x6a\x00\x7a\x02\x7b\x02\x7c\x02\x65\x00\x6e\x00\x66\x00\xc9\xfe\x67\x00\xc9\xfe\x68\x00\x69\x00\x6a\x00\x11\x01\x1f\x04\x6c\x00\x6d\x00\xb0\x01\x6f\x00\xb1\x01\x23\x00\x70\x00\x25\x00\x87\x01\x88\x01\x89\x01\xcb\x03\x4c\x01\xf2\x00\x6f\x00\x3a\x03\x3b\x03\x70\x00\x25\x00\x48\x03\x49\x03\x71\x00\x72\x00\x6e\x00\x6f\x00\x4c\x04\x20\x04\x70\x00\x25\x00\x07\x02\x69\x01\x08\x02\x71\x00\x72\x00\xc9\x02\x15\x01\x6f\x00\x55\x04\x23\x00\x70\x00\x25\x00\xf2\x00\x71\x00\x72\x00\xca\x02\xcb\x02\x6f\x00\xe7\x02\x85\x01\x70\x00\x25\x00\x8f\x01\xea\x02\xe0\x01\x71\x00\x72\x00\x6e\x00\xbe\x00\x51\x04\x68\x00\x69\x00\x6a\x00\x8f\x01\x90\x01\x71\x00\x72\x00\xa7\x00\x88\x03\x4e\x04\x6f\x00\xa8\x00\x23\x00\x70\x00\x25\x00\xd2\x00\xd3\x00\xf4\x00\x4f\x04\xd5\x00\x44\x04\xd6\x00\x33\x04\x21\x00\xa9\x00\x6e\x00\x34\x04\xaa\x00\x71\x00\x72\x00\x3d\x02\xa1\x00\xb3\x00\xb4\x00\x84\x01\x85\x01\xf3\x00\x3e\x04\x6f\x00\x38\x04\x23\x00\x70\x00\x25\x00\xd2\x00\xd3\x00\xf4\x00\x97\x02\xd5\x00\x3a\x04\xd6\x00\x6e\x00\x6f\x00\x3c\x02\x3d\x02\x70\x00\x25\x00\x71\x00\x72\x00\xf9\x00\x69\x00\x6a\x00\xfe\x01\xff\x01\x6f\x00\x1b\x04\x23\x00\x70\x00\x25\x00\x3c\x04\x71\x00\x72\x00\x6a\x02\x65\x00\xfe\x01\x66\x00\x4b\xff\x67\x00\x28\x04\x68\x00\x69\x00\x6a\x00\x71\x00\x72\x00\xea\x00\x6d\x00\x95\x02\x9b\x03\x8c\x03\x87\x03\x69\x00\x6a\x00\x2c\x04\x65\x00\x97\x02\x66\x00\x2d\x04\x67\x00\xf0\x03\x68\x00\x69\x00\x6a\x00\x3c\x02\x3d\x02\xea\x00\x6d\x00\x6a\x02\xeb\x00\x38\x04\x87\x03\x69\x00\x6a\x00\x9c\x03\x65\x00\xf3\x03\x66\x00\x8d\x03\x67\x00\xff\x03\x68\x00\x69\x00\x6a\x00\xe7\xfd\x36\x04\x6c\x00\x6d\x00\x58\x03\x59\x03\x6f\x00\xfc\x02\xfd\x02\x70\x00\x25\x00\x65\x00\x0a\x04\x66\x00\x0c\x04\x67\x00\x0b\x04\x68\x00\x69\x00\x6a\x00\x0f\x04\x1c\x04\x6c\x00\x6d\x00\x71\x00\x72\x00\x2a\x00\x2b\x00\x49\x02\x4a\x02\x6a\x02\x65\x00\xb8\x03\x66\x00\x16\x04\x67\x00\x7e\x02\x68\x00\x69\x00\x6a\x00\x17\x04\x28\x04\x6c\x00\x6d\x00\xf6\x02\xfe\x01\xff\x01\xbc\x03\xec\x00\x3c\x02\x3d\x02\x65\x00\xbd\x03\x66\x00\xbe\x03\x67\x00\xbf\x03\x68\x00\x69\x00\x6a\x00\xee\x01\xf9\x03\x6c\x00\x6d\x00\x6f\x00\xc1\x03\xc6\x03\x70\x00\x25\x00\xc9\x03\x2c\x00\x6e\x00\xd1\x03\xd5\x03\xd2\x03\x37\x03\x1d\x04\x87\x03\x69\x00\x6a\x00\xe5\x03\xe2\x03\x71\x00\x72\x00\x6f\x00\xe7\x03\x23\x00\x70\x00\x25\x00\xe8\x03\x6a\x02\x6e\x00\x68\x03\xee\x03\x6f\x00\xec\x03\x55\x03\x70\x00\x25\x00\x62\x03\x65\x03\x6a\x02\x71\x00\x72\x00\x6f\x00\x63\x03\x23\x00\x70\x00\x25\x00\x70\x03\x64\x03\x6e\x00\x71\x00\x72\x00\x6f\x00\x69\x03\x81\x03\x70\x00\x25\x00\x82\x03\xd4\x01\x8d\x02\x71\x00\x72\x00\x6f\x00\x86\x03\x23\x00\x70\x00\x25\x00\xe8\xfd\x8a\x03\x6e\x00\x71\x00\x72\x00\x98\x03\x97\x02\x1e\x04\x87\x03\x69\x00\x6a\x00\xa1\x03\xd3\x01\x71\x00\x72\x00\x6f\x00\xa4\x03\x23\x00\x70\x00\x25\x00\x2c\x00\xb0\x01\x6e\x00\xaf\x03\xf6\x02\xfa\x02\xf7\x02\x6a\x02\xfe\x02\xff\x02\x06\x03\x24\xff\x07\x03\x71\x00\x72\x00\x6f\x00\x08\x03\x23\x00\x70\x00\x25\x00\xe1\x01\x0a\x03\x6e\x00\x0b\x03\xbe\x00\x95\x02\x68\x00\x69\x00\x6a\x00\x12\x03\x97\x02\x97\x02\x28\x03\x71\x00\x72\x00\x6f\x00\x15\x03\x23\x00\x70\x00\x25\x00\x65\x00\xc5\x00\x66\x00\xc5\x00\x67\x00\x23\x03\x68\x00\x69\x00\x6a\x00\x2e\x03\xfd\x03\x6c\x00\x6d\x00\x71\x00\x72\x00\x6f\x00\x30\x03\x37\x03\x70\x00\x25\x00\x65\x00\x40\x03\x66\x00\x31\x03\x67\x00\x3e\x03\x68\x00\x69\x00\x6a\x00\x3f\x03\xe0\x03\x6c\x00\x6d\x00\x71\x00\x72\x00\x05\x04\x87\x03\x69\x00\x6a\x00\x47\x03\x65\x00\x48\x03\x66\x00\x4b\x03\x67\x00\xa3\x00\x68\x00\x69\x00\x6a\x00\x53\x03\x23\x03\x6c\x00\x6d\x00\x47\x02\x4b\x02\xc6\x03\x87\x03\x69\x00\x6a\x00\x4c\x02\x65\x00\xb6\x00\x66\x00\x53\x02\x67\x00\x52\x02\x68\x00\x69\x00\x6a\x00\x54\x02\x3c\x03\x6c\x00\x6d\x00\x55\x02\xfe\x01\x6f\x00\x5f\x02\x59\x02\x70\x00\x25\x00\x65\x00\x5a\x02\x66\x00\x5b\x02\x67\x00\x62\x02\x68\x00\x69\x00\x6a\x00\x63\x02\x5b\x02\x6c\x00\x6d\x00\x71\x00\x72\x00\x6c\x02\x29\xff\x6d\x02\xfe\x01\x73\x02\x65\x00\x7e\x02\x66\x00\x08\x02\x67\x00\x7e\x02\x68\x00\x69\x00\x6a\x00\x8d\x02\x99\x01\x6c\x00\x6d\x00\x6f\x00\x89\x02\x95\x02\x70\x00\x25\x00\x97\x02\x9c\x02\x6e\x00\xa4\x02\xa2\x02\xaa\x02\xab\x02\xc9\x03\x87\x03\x69\x00\x6a\x00\xae\x02\xb1\x02\x71\x00\x72\x00\x6f\x00\xb4\x02\x23\x00\x70\x00\x25\x00\xa8\x01\xdb\x02\x6e\x00\xdc\x02\xec\x02\xe4\x02\xea\x02\x86\x03\x87\x03\x69\x00\x6a\x00\xe5\x02\x2c\x00\x71\x00\x72\x00\x6f\x00\x92\x01\x23\x00\x70\x00\x25\x00\xb1\xfd\xb3\xfd\x6e\x00\xb2\xfd\xb5\xfd\x6f\x00\xb8\xfd\xa7\x01\x70\x00\x25\x00\xb6\x01\xa8\x01\xa9\x01\x71\x00\x72\x00\x6f\x00\xb1\x01\x23\x00\x70\x00\x25\x00\xc1\x01\xc0\x01\x6e\x00\x71\x00\x72\x00\x6f\x00\xc2\x01\xb7\x01\x70\x00\x25\x00\xc3\x01\xc8\x01\xea\x00\x71\x00\x72\x00\x6f\x00\xca\x01\x23\x00\x70\x00\x25\x00\xbf\x01\xd6\x01\x6e\x00\x71\x00\x72\x00\xd1\x01\xd3\x01\xd4\x01\xdb\x01\xdc\x01\xdd\x01\xe4\x01\xe5\x01\x71\x00\x72\x00\x6f\x00\xe8\x01\x23\x00\x70\x00\x25\x00\xe2\x01\x1b\x02\x6e\x00\xe6\x01\xbe\x00\xe9\x01\x68\x00\x69\x00\x6a\x00\xef\x01\x13\x02\xd4\x01\x25\x02\x71\x00\x72\x00\x6f\x00\xb8\x00\x23\x00\x70\x00\x25\x00\x65\x00\x29\x02\x66\x00\x32\x02\x67\x00\x33\x02\x68\x00\x69\x00\x6a\x00\x2c\x00\xfa\x01\x6c\x00\x6d\x00\x71\x00\x72\x00\x6f\x00\x39\x02\xa5\x00\x70\x00\x25\x00\x65\x00\x42\x02\x66\x00\xb6\x00\x67\x00\xff\xff\x68\x00\x69\x00\x6a\x00\xb8\x00\xff\x01\x6c\x00\x6d\x00\x71\x00\x72\x00\x6f\x00\xc5\x00\xc7\x00\x70\x00\x25\x00\x65\x00\xc8\x00\x66\x00\xc9\x00\x67\x00\xf8\x00\x68\x00\x69\x00\x6a\x00\xff\xff\x4d\x01\x6c\x00\x6d\x00\x71\x00\x72\x00\xe7\x00\x04\x01\x05\x01\xff\xff\x06\x01\x65\x00\x09\x01\x66\x00\xc5\x00\x67\x00\x09\x01\x68\x00\x69\x00\x6a\x00\xff\xff\x6b\x00\x6c\x00\x6d\x00\x7c\x01\x7d\x01\x0d\xfe\xff\xff\xff\xff\xa5\x00\x00\x00\x65\x00\x00\x00\x66\x00\x00\x00\x67\x00\x00\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x02\x04\x6d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x00\x00\x66\x00\x00\x00\x67\x00\x00\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x9c\x02\x6d\x00\x6f\x00\x00\x00\x00\x00\x70\x00\x25\x00\x00\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\x71\x00\x72\x00\x6f\x00\x00\x00\x23\x00\x70\x00\x25\x00\x00\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\x71\x00\x72\x00\x6f\x00\x00\x00\x23\x00\x70\x00\x25\x00\x00\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\x71\x00\x72\x00\x6f\x00\x00\x00\x23\x00\x70\x00\x25\x00\x00\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\x71\x00\x72\x00\x6f\x00\x00\x00\x23\x00\x70\x00\x25\x00\x00\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\x71\x00\x72\x00\x6f\x00\x00\x00\x23\x00\x70\x00\x25\x00\xbd\x00\x00\x00\x6e\x00\x00\x00\xbe\x00\x00\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x71\x00\x72\x00\x6f\x00\x00\x00\x23\x00\x70\x00\x25\x00\x65\x00\x00\x00\x66\x00\x00\x00\x67\x00\x00\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x9e\x02\x6d\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x00\x00\x66\x00\x00\x00\x67\x00\x00\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\xa0\x02\x6d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x00\x00\x66\x00\x00\x00\x67\x00\x00\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\xde\x01\x6d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x00\x00\x66\x00\x00\x00\x67\x00\x00\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x13\x02\x6d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x00\x00\x66\x00\x00\x00\x67\x00\x00\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x18\x02\x6d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x00\x00\x66\x00\x00\x00\x67\x00\x00\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x27\x02\x6d\x00\x6f\x00\x00\x00\x00\x00\x70\x00\x25\x00\x00\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\x71\x00\x72\x00\x6f\x00\x00\x00\x23\x00\x70\x00\x25\x00\x00\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\x71\x00\x72\x00\x6f\x00\x00\x00\x23\x00\x70\x00\x25\x00\x00\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\x71\x00\x72\x00\x6f\x00\x00\x00\x23\x00\x70\x00\x25\x00\x00\x00\x65\x00\x6e\x00\xe8\x00\x00\x00\xbe\x00\x00\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x71\x00\x72\x00\x6f\x00\x00\x00\x23\x00\x70\x00\x25\x00\x00\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\x71\x00\x72\x00\x6f\x00\x00\x00\x23\x00\x70\x00\x25\x00\x00\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\x71\x00\x72\x00\x6f\x00\x00\x00\x23\x00\x70\x00\x25\x00\x65\x00\x00\x00\x66\x00\x00\x00\x67\x00\x00\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\xc5\x00\x6d\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x00\x00\x66\x00\x00\x00\x67\x00\x00\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\xc9\x00\x6d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x00\x00\x66\x00\x00\x00\x67\x00\x00\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\xe3\x00\x6d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x6e\x00\x66\x00\x00\x00\x67\x00\x00\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\xf8\x00\x6d\x00\x00\x00\x6f\x00\x00\x00\x23\x00\x70\x00\x25\x00\x00\x00\x16\x03\x17\x03\x00\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x18\x03\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x16\x03\x90\x03\x00\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x03\x1a\x03\x1b\x03\x00\x00\x1c\x03\xae\x00\xaf\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x91\x03\x1a\x03\x1b\x03\x00\x00\x1c\x03\xf9\x00\x69\x00\x6a\x00\xfa\x00\x6f\x00\x00\x00\x23\x00\x70\x00\x25\x00\x00\x00\x00\x00\x6e\x00\xb2\x00\xaf\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x4e\x02\xb0\x00\xb1\x00\x00\x00\x71\x00\x72\x00\x6f\x00\x00\x00\x23\x00\x70\x00\x25\x00\x55\x01\x00\x00\x6e\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x71\x00\x72\x00\x6f\x00\x00\x00\x23\x00\x70\x00\x25\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x01\x00\x00\x00\x00\x4a\x01\x71\x00\x72\x00\x6f\x00\x00\x00\x23\x00\x70\x00\x25\x00\x00\x00\x1d\x03\x20\x00\x21\x00\x22\x00\x1c\x00\x24\x00\x25\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x6f\x00\x71\x00\x72\x00\x1e\x03\x25\x00\x00\x00\x1d\x03\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x6f\x00\x71\x00\x72\x00\x1e\x03\x25\x00\x26\x00\x00\x00\x00\x00\xa7\x00\x00\x00\x00\x00\x00\x00\xa8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\xfb\x00\x21\x00\xa9\x00\x00\x00\xd1\x00\xaa\x00\x6f\x00\x00\x00\x00\x00\x70\x00\x25\x00\xd2\x00\xd3\x00\x00\x00\xa7\x00\x00\x00\x00\x00\x00\x00\xa8\x00\xa7\x00\x00\x00\x00\x00\x00\x00\xa8\x00\x71\x00\x72\x00\xfc\x00\xfd\x00\x00\x00\x00\x00\x21\x00\xa9\x00\x00\x00\x00\x00\xaa\x00\x21\x00\xa9\x00\x00\x00\x00\x00\xaa\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x6a\x02\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x58\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x52\x03\x00\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x5f\x00\x00\x00\x90\x00\x00\x00\x60\x00\x00\x00\x00\x00\x91\x00\x00\x00\x00\x00\x62\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\x00\x96\x00\x63\x00\x64\x00\x65\x00\x97\x00\x98\x00\x00\x00\x00\x00\x00\x00\x99\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\xce\x00\x39\x00\x00\x00\xcf\x00\x00\x00\x7e\x01\x00\x00\xd1\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\xd2\x00\xd3\x00\xd4\x00\x00\x00\xd5\x00\x3c\x00\xd6\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x58\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x52\x03\x00\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x5f\x00\x00\x00\x90\x00\x00\x00\x60\x00\x00\x00\x00\x00\x91\x00\x00\x00\x00\x00\x62\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\x00\x96\x00\x63\x00\x64\x00\x65\x00\x97\x00\x98\x00\x00\x00\x00\x00\x00\x00\x99\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x58\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x5f\x00\x28\x00\x90\x00\x00\x00\x60\x00\x2c\x00\x2d\x00\x91\x00\x00\x00\x42\xff\x62\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\x00\x96\x00\x63\x00\x64\x00\x65\x00\x97\x00\x98\x00\x74\x00\x00\x00\x75\x00\x99\x00\x28\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x76\x00\x00\x00\x00\x00\x00\x00\x42\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x93\x03\x03\x01\x00\x00\x94\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\x28\x00\x00\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x74\x00\x00\x00\x75\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x76\x00\x5c\x00\x42\xff\x00\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x74\x00\x00\x00\x75\x00\x22\x04\x00\x00\x62\x00\x00\x00\x00\x00\x28\x00\x29\x00\x76\x00\x5c\x00\x2c\x00\x2d\x00\x42\xff\x00\x00\x00\x00\x95\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x94\x03\x4c\x01\x62\x00\x00\x00\x00\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x7a\x00\x00\x00\x5c\x00\x2c\x00\x2d\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x74\x00\x62\x00\x75\x00\x00\x00\x28\x00\x00\x00\x00\x00\x5c\x00\x2c\x00\x2d\x00\x76\x00\x00\x00\x00\x00\x23\x04\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x74\x00\x62\x00\x75\x00\x21\x03\x28\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x5b\x00\x76\x00\x5c\x00\x00\x00\x95\x03\x00\x00\x00\x00\x00\x00\x00\x00\x77\x02\x00\x00\x00\x00\x61\x03\x00\x00\x00\x00\x00\x00\x78\x02\x00\x00\x00\x00\x8f\x03\x00\x00\x62\x00\x00\x00\x00\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x20\x03\x00\x00\x75\x00\x00\x00\x00\x00\x62\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\x76\x00\x5c\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x22\x03\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x00\x00\x00\x00\x21\x03\x00\x00\x62\x00\x00\x00\x00\x00\x00\x00\xdd\x00\xde\x00\x5c\x00\xdf\x00\x80\x01\x00\x00\x00\x00\x00\x00\x90\x03\x00\x00\x00\x00\x00\x00\x00\x00\xe1\x00\xe2\x00\xe3\x00\x81\x01\x82\x01\x83\x01\x84\x01\x00\x00\x62\x00\x00\x00\x00\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x5c\x00\x64\x01\xd9\x00\xda\x00\xdb\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\xe3\x02\x39\x00\x00\x00\x62\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\xaf\x01\x3b\x00\x66\x01\x67\x01\x22\x03\xdf\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x68\x01\x69\x01\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\xdd\x00\xde\x00\x00\x00\xdf\x00\xde\x03\x00\x00\x8f\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\xe1\x00\xe2\x00\xe3\x00\x00\x00\x62\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x63\x00\x64\x00\x65\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x64\x01\xd9\x00\xda\x00\xdb\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\xae\x01\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\xaf\x01\x3b\x00\x66\x01\x67\x01\x00\x00\xdf\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x68\x01\x69\x01\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\xdd\x00\xde\x00\x00\x00\xdf\x00\x00\x00\x00\x00\x8f\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\xe1\x00\xe2\x00\xe3\x00\x00\x00\x62\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x63\x00\x64\x00\x65\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x73\x01\xd9\x00\xda\x00\xdb\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x74\x01\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\xef\x00\x3b\x00\x66\x01\x75\x01\x00\x00\xdf\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x76\x01\x77\x01\x78\x01\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x63\x00\x64\x00\x65\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x64\x01\xd9\x00\xda\x00\xdb\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x65\x01\x00\x00\x3b\x00\x66\x01\x67\x01\x00\x00\xdf\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x68\x01\x69\x01\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x63\x00\x64\x00\x65\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x64\x01\xd9\x00\xda\x00\xdb\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x66\x01\x67\x01\x00\x00\xdf\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x68\x01\x69\x01\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x63\x00\x64\x00\x65\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\xd9\x01\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x60\x00\x61\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x63\x00\x64\x00\x65\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x6a\x02\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\xcd\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x63\x00\x64\x00\x65\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\xce\x00\x39\x00\x00\x00\xcf\x00\x00\x00\xd0\x00\x00\x00\xd1\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\xd2\x00\xd3\x00\xd4\x00\x00\x00\xd5\x00\x3c\x00\xd6\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x02\x5f\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\xd6\x02\x00\x00\x00\x00\x00\x00\x62\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x63\x00\x64\x00\x65\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x60\x00\x61\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x63\x00\x64\x00\x65\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x63\x00\x64\x00\x65\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x02\x5f\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x63\x00\x64\x00\x65\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\xf5\x02\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x63\x00\x64\x00\x65\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x02\x5f\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x63\x00\x64\x00\x65\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x63\x00\x64\x00\x65\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\xff\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x63\x00\x64\x00\x65\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x6a\x02\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x1f\xff\x1f\xff\x1f\xff\x1f\xff\x1f\xff\x1f\xff\x1f\xff\x1f\xff\x1f\xff\x1f\xff\x1f\xff\x3d\x00\x00\x00\x3e\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x1f\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x1f\xff\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\xda\x03\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x8b\x00\x8c\x00\x8d\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdb\x03\x00\x00\x00\x00\x62\x00\x92\x00\x93\x00\x94\x00\x95\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\xda\x03\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x8b\x00\x8c\x00\x8d\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdb\x03\x00\x00\x00\x00\x62\x00\x92\x00\x93\x00\x94\x00\x95\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x6a\x02\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x78\x03\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x9b\x01\x5c\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x90\x00\x19\x00\x00\x00\x00\x00\x00\x00\x79\x03\x00\x00\x00\x00\x62\x00\x92\x00\x93\x00\x94\x00\x95\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x1c\x00\x39\x00\x00\x00\x1d\x00\x1e\x00\x6a\x02\x1f\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x85\x00\x00\x00\x26\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x28\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x8b\x00\x8c\x00\x8d\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x62\x00\x92\x00\x93\x00\x94\x00\x95\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x3d\x00\x00\x00\x3e\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x5c\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x62\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x78\x03\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x57\x01\x58\x01\x0a\x01\x17\x00\x18\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x90\x00\x19\x00\x00\x00\x00\x00\x00\x00\x79\x03\x00\x00\x00\x00\x62\x00\x92\x00\x93\x00\x94\x00\x95\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x1c\x00\x39\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x85\x00\x00\x00\x26\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x8b\x00\x8c\x00\x8d\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x92\x00\x93\x00\x94\x00\x95\x00\xb9\x02\x29\x00\x2a\x00\x2b\x00\xba\x02\x2d\x00\x19\x01\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1a\x01\xbb\x02\xbc\x02\xbd\x02\xbe\x02\xbf\x02\xc0\x02\xc1\x02\xc2\x02\xc3\x02\xc4\x02\xc5\x02\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\x2c\x01\x2d\x01\xc6\x02\xc7\x02\x30\x01\xc8\x02\x32\x01\x33\x01\x34\x01\x35\x01\x36\x01\x37\x01\x38\x01\x39\x01\x3a\x01\x3b\x01\x3c\x01\x3d\x01\x3e\x01\x3f\x01\x40\x01\x41\x01\x42\x01\x43\x01\xc9\x02\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x62\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbc\x01\x00\x00\x3d\x00\x28\x00\x00\x00\x0c\x01\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x74\x00\x4a\x00\x75\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x76\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x3d\x00\x00\x00\x00\x00\x0c\x01\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x00\x40\x00\x00\x00\x5c\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\xc1\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x62\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x01\x00\x00\x00\x00\x3d\x00\x18\x01\x00\x00\x19\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x5b\x00\xdc\x00\x5c\x00\xdd\x00\xde\x00\x00\x00\xdf\x00\xe0\x00\xc8\xfe\x00\x00\xc8\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe1\x00\xe2\x00\xe3\x00\x00\x00\x00\x00\x62\x00\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\x21\x01\x22\x01\x23\x01\x24\x01\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\x2c\x01\x2d\x01\x2e\x01\x2f\x01\x30\x01\x31\x01\x32\x01\x33\x01\x34\x01\x35\x01\x36\x01\x37\x01\x38\x01\x39\x01\x3a\x01\x3b\x01\x3c\x01\x3d\x01\x3e\x01\x3f\x01\x40\x01\x41\x01\x42\x01\x43\x01\x44\x01\x28\x00\x00\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x74\x00\xf6\x00\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x76\x00\x00\x00\xef\x00\x00\x00\x00\x00\xde\x00\xdc\x00\xdf\x00\xdd\x00\xde\x00\x00\x00\xdf\x00\xe0\x00\xf7\x00\x00\x00\x00\x00\x00\x00\xe1\x00\xe2\x00\xe3\x00\x00\x00\xe1\x00\xe2\x00\xe3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x28\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\xff\x00\xd9\x00\x7a\x00\xdb\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x74\x00\x00\x00\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x62\x00\x76\x00\x00\x00\x2c\x00\x2d\x00\x00\x01\xff\x00\xd9\x00\xdf\x00\xdb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x01\x00\x00\x02\x01\x03\x01\x00\x00\x00\x00\x74\x00\x00\x00\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x76\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\xdf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x01\x00\x00\x24\x02\x00\x00\x00\x00\x00\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x5c\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x62\x00\x74\x00\x00\x00\x75\x00\xee\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\x00\x00\x5c\x00\x76\x00\x00\x00\xef\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x00\x00\x00\x28\x00\x00\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x62\x00\x00\x00\xef\x00\x00\x00\x00\x00\xde\x00\x00\x00\xdf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf7\x00\x74\x00\x9e\x03\x75\x00\xe1\x00\xe2\x00\xe3\x00\x00\x00\x00\x00\x00\x00\x28\x00\x76\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x00\x00\x00\x00\x74\x00\x00\x00\x75\x00\x00\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x5c\x00\x00\x00\x76\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x62\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x00\x00\x00\x00\x74\x00\x00\x00\x75\x00\x00\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x5c\x00\x00\x00\x76\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x62\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe5\x00\x00\x00\x00\x00\x28\x00\x29\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x62\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x4c\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x5c\x00\x60\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x62\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\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x76\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x00\x00\x00\x00\x74\x00\x00\x00\x75\x00\x00\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x76\x00\xea\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x03\x00\x00\x00\x00\x28\x00\x00\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x62\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x00\x00\x00\x00\x74\x00\x00\x00\x75\x00\x00\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x5c\x00\x28\x00\x76\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x62\x00\x00\x00\x00\x00\x74\x00\x00\x00\x75\x00\x28\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x5c\x00\x00\x00\x76\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\x53\x04\x00\x00\x62\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x54\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x62\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\xac\x00\xf8\x03\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x62\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x74\x00\x00\x00\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x76\x00\xac\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\xa3\x02\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x78\x02\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x62\x00\x00\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x5c\x00\x00\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x03\x00\x00\x62\x00\x00\x00\xad\x00\x00\x00\xba\x00\x00\x00\x28\x00\x00\x00\xae\x00\x4d\x00\x2c\x00\x62\x00\xa0\x01\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\xa1\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x00\x00\x28\x00\x29\x00\x00\x00\x5c\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x4c\x01\x62\x00\x28\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\xac\x00\x00\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x62\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x60\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\x00\x00\xba\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x62\x00\xd0\x03\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x74\x00\x00\x00\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x5a\x00\x5b\x00\x76\x00\x5c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x28\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x62\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x74\x00\x00\x00\x75\x00\x00\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x62\x00\x76\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\xba\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x62\x00\x00\x00\x00\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x74\x00\x00\x00\x75\x00\x28\x00\x29\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x76\x00\x5c\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x00\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x62\x00\x00\x00\x00\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x74\x00\x00\x00\x75\x00\x28\x00\x29\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x76\x00\x5c\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x62\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x74\x00\x00\x00\x75\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x76\x00\x5c\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\xba\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x62\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x47\x01\x00\x00\x48\x01\x28\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x49\x01\x5c\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\xac\x00\x00\x00\x28\x00\x29\x00\x00\x00\x00\x00\x62\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\xba\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x62\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\xac\x00\x00\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\xba\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x62\x00\x2c\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\xac\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x62\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x45\x03\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x62\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x26\x03\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x62\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x45\x03\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x62\x00\x2c\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x62\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x62\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\xf2\x01\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x96\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf2\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf3\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\x4d\x00\x77\x00\x78\x00\x79\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x7e\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x62\x00\x13\x00\x14\x00\x15\x00\x5c\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x00\x00\xd0\x02\xd1\x02\xd2\x02\xd3\x02\x00\x00\xd4\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x7e\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaa\x03\xd2\x02\xd3\x02\x00\x00\xd4\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x7e\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x03\xd3\x02\x00\x00\xd4\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x7e\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x04\x80\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1a\x00\x00\x00\x04\x03\x00\x00\xd7\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x7e\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7f\x02\x80\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1a\x00\x00\x00\xa7\x02\x00\x00\xd7\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x7e\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcd\x02\x80\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1a\x00\x00\x00\xd6\x01\x00\x00\xd7\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1a\x00\x00\x00\xd9\x01\x00\x00\xd7\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x7e\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x3a\x04\x9c\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x1a\x00\x00\x00\x00\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x17\x04\x9c\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x11\x04\x9c\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xb0\x03\x9c\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\xb1\x03\x9c\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xb2\x03\x9c\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\xe2\x03\x9c\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x6d\x03\x9c\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x82\x03\x9c\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x83\x03\x9c\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\xf3\x02\x9c\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x83\x02\x9c\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\xa1\x01\x9c\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x50\x01\x9c\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x51\x01\x9c\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x9b\x00\x9c\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x6b\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x6c\x01\x6d\x01\x00\x00\x00\x00\x6e\x01\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x5d\x01\x00\x00\x5e\x01\x00\x00\x00\x00\x5f\x01\x6f\x01\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xd2\x00\xd3\x00\x70\x01\x60\x01\xd5\x00\x61\x01\x71\x01\x26\x00\x59\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x5a\x01\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x01\x5c\x01\xd7\x02\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\xd8\x02\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x5d\x01\x00\x00\x5e\x01\x00\x00\x00\x00\x5f\x01\xd1\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xd2\x00\xd3\x00\x00\x00\x60\x01\x00\x00\x61\x01\x62\x01\x26\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x5d\x01\x00\x00\x5e\x01\x00\x00\x00\x00\x5f\x01\xd1\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xd2\x00\xd3\x00\x00\x00\x60\x01\x00\x00\x61\x01\x62\x01\x26\x00\x59\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\xd9\x02\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\xe1\x02\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x5d\x01\x00\x00\x5e\x01\x00\x00\x00\x00\x5f\x01\xd1\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xd2\x00\xd3\x00\x00\x00\x60\x01\x00\x00\x61\x01\x62\x01\x26\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x5d\x01\x00\x00\x5e\x01\x00\x00\x00\x00\x5f\x01\xd1\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xd2\x00\xd3\x00\x00\x00\x60\x01\x00\x00\x61\x01\x62\x01\x26\x00\x59\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\xac\x01\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x5d\x01\x00\x00\x5e\x01\x00\x00\x00\x00\x5f\x01\xd1\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xd2\x00\xd3\x00\x00\x00\x60\x01\x00\x00\x61\x01\x62\x01\x26\x00\x99\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x99\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\xa4\x03\xa5\x03\x00\x00\x19\x00\x00\x00\xa6\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x10\x04\x00\x00\x00\x00\x00\x00\xa6\x03\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\xb1\x02\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\xb2\x02\x00\x00\x19\x00\x00\x00\xdd\x02\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xde\x02\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x52\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x53\x01\x00\x00\x19\x00\x00\x00\x99\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9a\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x3c\x04\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x0f\x04\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\xaf\x03\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\xef\x02\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x03\x03\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\xa4\x02\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\xa5\x02\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\xab\x02\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\xac\x02\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\xce\x02\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\xcf\x02\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\xd6\x02\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\xdc\x02\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x95\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x96\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x97\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x98\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x0e\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x10\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x12\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x45\x03\x10\x00\x4f\x01\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\xb4\x01\x10\x00\x4f\x01\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x4e\x01\x10\x00\x4f\x01\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9a\x01\x00\x00\x00\x00\x9b\x01\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xba\x01\x0a\x01\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x26\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x09\x01\x0a\x01\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xb4\x02\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x19\x00\x00\x00\x00\x00\xb5\x02\x14\x01\x15\x01\x00\x00\xb6\x02\x4c\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb4\x02\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\xb5\x02\x14\x01\x15\x01\x00\x00\xb6\x02\xb7\x02\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\xa7\x03\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x4c\x02\x17\x00\x18\x00\x1c\x00\x00\x00\x26\x00\x1d\x00\x1e\x00\x19\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\xa2\x01\x17\x00\x18\x00\x00\x00\x00\x00\x26\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\xa3\x01\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x26\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x7d\x01\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\xd4\x01\x17\x00\x18\x00\x1c\x00\x00\x00\x26\x00\x1d\x00\x1e\x00\x19\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x35\x02\x17\x00\x18\x00\x00\x00\x00\x00\x26\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x39\x02\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x26\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\xcc\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x54\x01\x17\x00\x18\x00\x1c\x00\x00\x00\x26\x00\x1d\x00\x1e\x00\x19\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x56\x01\x17\x00\x18\x00\x00\x00\x00\x00\x26\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x7d\x01\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x26\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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 = array (8, 620) [-	(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),-	(371 , happyReduce_371),-	(372 , happyReduce_372),-	(373 , happyReduce_373),-	(374 , happyReduce_374),-	(375 , happyReduce_375),-	(376 , happyReduce_376),-	(377 , happyReduce_377),-	(378 , happyReduce_378),-	(379 , happyReduce_379),-	(380 , happyReduce_380),-	(381 , happyReduce_381),-	(382 , happyReduce_382),-	(383 , happyReduce_383),-	(384 , happyReduce_384),-	(385 , happyReduce_385),-	(386 , happyReduce_386),-	(387 , happyReduce_387),-	(388 , happyReduce_388),-	(389 , happyReduce_389),-	(390 , happyReduce_390),-	(391 , happyReduce_391),-	(392 , happyReduce_392),-	(393 , happyReduce_393),-	(394 , happyReduce_394),-	(395 , happyReduce_395),-	(396 , happyReduce_396),-	(397 , happyReduce_397),-	(398 , happyReduce_398),-	(399 , happyReduce_399),-	(400 , happyReduce_400),-	(401 , happyReduce_401),-	(402 , happyReduce_402),-	(403 , happyReduce_403),-	(404 , happyReduce_404),-	(405 , happyReduce_405),-	(406 , happyReduce_406),-	(407 , happyReduce_407),-	(408 , happyReduce_408),-	(409 , happyReduce_409),-	(410 , happyReduce_410),-	(411 , happyReduce_411),-	(412 , happyReduce_412),-	(413 , happyReduce_413),-	(414 , happyReduce_414),-	(415 , happyReduce_415),-	(416 , happyReduce_416),-	(417 , happyReduce_417),-	(418 , happyReduce_418),-	(419 , happyReduce_419),-	(420 , happyReduce_420),-	(421 , happyReduce_421),-	(422 , happyReduce_422),-	(423 , happyReduce_423),-	(424 , happyReduce_424),-	(425 , happyReduce_425),-	(426 , happyReduce_426),-	(427 , happyReduce_427),-	(428 , happyReduce_428),-	(429 , happyReduce_429),-	(430 , happyReduce_430),-	(431 , happyReduce_431),-	(432 , happyReduce_432),-	(433 , happyReduce_433),-	(434 , happyReduce_434),-	(435 , happyReduce_435),-	(436 , happyReduce_436),-	(437 , happyReduce_437),-	(438 , happyReduce_438),-	(439 , happyReduce_439),-	(440 , happyReduce_440),-	(441 , happyReduce_441),-	(442 , happyReduce_442),-	(443 , happyReduce_443),-	(444 , happyReduce_444),-	(445 , happyReduce_445),-	(446 , happyReduce_446),-	(447 , happyReduce_447),-	(448 , happyReduce_448),-	(449 , happyReduce_449),-	(450 , happyReduce_450),-	(451 , happyReduce_451),-	(452 , happyReduce_452),-	(453 , happyReduce_453),-	(454 , happyReduce_454),-	(455 , happyReduce_455),-	(456 , happyReduce_456),-	(457 , happyReduce_457),-	(458 , happyReduce_458),-	(459 , happyReduce_459),-	(460 , happyReduce_460),-	(461 , happyReduce_461),-	(462 , happyReduce_462),-	(463 , happyReduce_463),-	(464 , happyReduce_464),-	(465 , happyReduce_465),-	(466 , happyReduce_466),-	(467 , happyReduce_467),-	(468 , happyReduce_468),-	(469 , happyReduce_469),-	(470 , happyReduce_470),-	(471 , happyReduce_471),-	(472 , happyReduce_472),-	(473 , happyReduce_473),-	(474 , happyReduce_474),-	(475 , happyReduce_475),-	(476 , happyReduce_476),-	(477 , happyReduce_477),-	(478 , happyReduce_478),-	(479 , happyReduce_479),-	(480 , happyReduce_480),-	(481 , happyReduce_481),-	(482 , happyReduce_482),-	(483 , happyReduce_483),-	(484 , happyReduce_484),-	(485 , happyReduce_485),-	(486 , happyReduce_486),-	(487 , happyReduce_487),-	(488 , happyReduce_488),-	(489 , happyReduce_489),-	(490 , happyReduce_490),-	(491 , happyReduce_491),-	(492 , happyReduce_492),-	(493 , happyReduce_493),-	(494 , happyReduce_494),-	(495 , happyReduce_495),-	(496 , happyReduce_496),-	(497 , happyReduce_497),-	(498 , happyReduce_498),-	(499 , happyReduce_499),-	(500 , happyReduce_500),-	(501 , happyReduce_501),-	(502 , happyReduce_502),-	(503 , happyReduce_503),-	(504 , happyReduce_504),-	(505 , happyReduce_505),-	(506 , happyReduce_506),-	(507 , happyReduce_507),-	(508 , happyReduce_508),-	(509 , happyReduce_509),-	(510 , happyReduce_510),-	(511 , happyReduce_511),-	(512 , happyReduce_512),-	(513 , happyReduce_513),-	(514 , happyReduce_514),-	(515 , happyReduce_515),-	(516 , happyReduce_516),-	(517 , happyReduce_517),-	(518 , happyReduce_518),-	(519 , happyReduce_519),-	(520 , happyReduce_520),-	(521 , happyReduce_521),-	(522 , happyReduce_522),-	(523 , happyReduce_523),-	(524 , happyReduce_524),-	(525 , happyReduce_525),-	(526 , happyReduce_526),-	(527 , happyReduce_527),-	(528 , happyReduce_528),-	(529 , happyReduce_529),-	(530 , happyReduce_530),-	(531 , happyReduce_531),-	(532 , happyReduce_532),-	(533 , happyReduce_533),-	(534 , happyReduce_534),-	(535 , happyReduce_535),-	(536 , happyReduce_536),-	(537 , happyReduce_537),-	(538 , happyReduce_538),-	(539 , happyReduce_539),-	(540 , happyReduce_540),-	(541 , happyReduce_541),-	(542 , happyReduce_542),-	(543 , happyReduce_543),-	(544 , happyReduce_544),-	(545 , happyReduce_545),-	(546 , happyReduce_546),-	(547 , happyReduce_547),-	(548 , happyReduce_548),-	(549 , happyReduce_549),-	(550 , happyReduce_550),-	(551 , happyReduce_551),-	(552 , happyReduce_552),-	(553 , happyReduce_553),-	(554 , happyReduce_554),-	(555 , happyReduce_555),-	(556 , happyReduce_556),-	(557 , happyReduce_557),-	(558 , happyReduce_558),-	(559 , happyReduce_559),-	(560 , happyReduce_560),-	(561 , happyReduce_561),-	(562 , happyReduce_562),-	(563 , happyReduce_563),-	(564 , happyReduce_564),-	(565 , happyReduce_565),-	(566 , happyReduce_566),-	(567 , happyReduce_567),-	(568 , happyReduce_568),-	(569 , happyReduce_569),-	(570 , happyReduce_570),-	(571 , happyReduce_571),-	(572 , happyReduce_572),-	(573 , happyReduce_573),-	(574 , happyReduce_574),-	(575 , happyReduce_575),-	(576 , happyReduce_576),-	(577 , happyReduce_577),-	(578 , happyReduce_578),-	(579 , happyReduce_579),-	(580 , happyReduce_580),-	(581 , happyReduce_581),-	(582 , happyReduce_582),-	(583 , happyReduce_583),-	(584 , happyReduce_584),-	(585 , happyReduce_585),-	(586 , happyReduce_586),-	(587 , happyReduce_587),-	(588 , happyReduce_588),-	(589 , happyReduce_589),-	(590 , happyReduce_590),-	(591 , happyReduce_591),-	(592 , happyReduce_592),-	(593 , happyReduce_593),-	(594 , happyReduce_594),-	(595 , happyReduce_595),-	(596 , happyReduce_596),-	(597 , happyReduce_597),-	(598 , happyReduce_598),-	(599 , happyReduce_599),-	(600 , happyReduce_600),-	(601 , happyReduce_601),-	(602 , happyReduce_602),-	(603 , happyReduce_603),-	(604 , happyReduce_604),-	(605 , happyReduce_605),-	(606 , happyReduce_606),-	(607 , happyReduce_607),-	(608 , happyReduce_608),-	(609 , happyReduce_609),-	(610 , happyReduce_610),-	(611 , happyReduce_611),-	(612 , happyReduce_612),-	(613 , happyReduce_613),-	(614 , happyReduce_614),-	(615 , happyReduce_615),-	(616 , happyReduce_616),-	(617 , happyReduce_617),-	(618 , happyReduce_618),-	(619 , happyReduce_619),-	(620 , happyReduce_620)-	]--happy_n_terms = 139 :: Int-happy_n_nonterms = 222 :: Int--happyReduce_8 = happySpecReduce_2  0# happyReduction_8-happyReduction_8 happy_x_2-	happy_x_1-	 =  case happyOut15 happy_x_1 of { happy_var_1 -> -	case happyOut12 happy_x_2 of { happy_var_2 -> -	happyIn11-		 (let (os,ss,l) = happy_var_1 in map (\x -> x os ss l) happy_var_2-	)}}--happyReduce_9 = happySpecReduce_2  1# happyReduction_9-happyReduction_9 happy_x_2-	happy_x_1-	 =  case happyOut19 happy_x_1 of { happy_var_1 -> -	case happyOut12 happy_x_2 of { happy_var_2 -> -	happyIn12-		 (happy_var_1 : happy_var_2-	)}}--happyReduce_10 = happySpecReduce_1  1# happyReduction_10-happyReduction_10 happy_x_1-	 =  case happyOut19 happy_x_1 of { happy_var_1 -> -	happyIn12-		 ([happy_var_1]-	)}--happyReduce_11 = happyMonadReduce 2# 2# happyReduction_11-happyReduction_11 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut15 happy_x_1 of { happy_var_1 -> -	case happyOut14 happy_x_2 of { happy_var_2 -> -	( checkPageModule happy_var_2 happy_var_1)}}-	) (\r -> happyReturn (happyIn13 r))--happyReduce_12 = happyMonadReduce 5# 2# happyReduction_12-happyReduction_12 (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_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 XCodeTagOpen) -> -	case happyOut19 happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { (Loc happy_var_4 XCodeTagClose) -> -	case happyOut14 happy_x_5 of { happy_var_5 -> -	( let (os,ss,l) = happy_var_1 in checkHybridModule happy_var_5 (happy_var_3 os ss l) happy_var_2 happy_var_4)}}}}}-	) (\r -> happyReturn (happyIn13 r))--happyReduce_13 = happySpecReduce_2  2# happyReduction_13-happyReduction_13 happy_x_2-	happy_x_1-	 =  case happyOut15 happy_x_1 of { happy_var_1 -> -	case happyOut19 happy_x_2 of { happy_var_2 -> -	happyIn13-		 (let (os,ss,l) = happy_var_1 in happy_var_2 os ss l-	)}}--happyReduce_14 = happyMonadReduce 9# 3# happyReduction_14-happyReduction_14 (happy_x_9 `HappyStk`-	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) tk-	 = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 XStdTagOpen) -> -	case happyOut163 happy_x_2 of { happy_var_2 -> -	case happyOut166 happy_x_3 of { happy_var_3 -> -	case happyOut168 happy_x_4 of { happy_var_4 -> -	case happyOutTok happy_x_5 of { (Loc happy_var_5 XStdTagClose) -> -	case happyOut161 happy_x_6 of { happy_var_6 -> -	case happyOutTok happy_x_7 of { (Loc happy_var_7 XCloseTagOpen) -> -	case happyOut163 happy_x_8 of { happy_var_8 -> -	case happyOutTok happy_x_9 of { (Loc happy_var_9 XStdTagClose) -> -	( do { n <- checkEqNames happy_var_2 happy_var_8;-                                                                       let { cn = reverse happy_var_6;-                                                                             as = reverse happy_var_3; };-                                                                       return $ XTag (happy_var_1 <^^> happy_var_9 <** [happy_var_1,happy_var_5,happy_var_7,happy_var_9]) n as happy_var_4 cn })}}}}}}}}}-	) (\r -> happyReturn (happyIn14 r))--happyReduce_15 = happyReduce 5# 3# happyReduction_15-happyReduction_15 (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 { (Loc happy_var_1 XStdTagOpen) -> -	case happyOut163 happy_x_2 of { happy_var_2 -> -	case happyOut166 happy_x_3 of { happy_var_3 -> -	case happyOut168 happy_x_4 of { happy_var_4 -> -	case happyOutTok happy_x_5 of { (Loc happy_var_5 XEmptyTagClose) -> -	happyIn14-		 (XETag (happy_var_1 <^^> happy_var_5 <** [happy_var_1,happy_var_5]) happy_var_2 (reverse happy_var_3) happy_var_4-	) `HappyStk` happyRest}}}}}--happyReduce_16 = happySpecReduce_3  4# happyReduction_16-happyReduction_16 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut224 happy_x_1 of { happy_var_1 -> -	case happyOut16 happy_x_2 of { happy_var_2 -> -	case happyOut225 happy_x_3 of { happy_var_3 -> -	happyIn15-		 (let (os,ss,ml) = happy_var_2 in (os,happy_var_1:ss++[happy_var_3],happy_var_1 <^^> happy_var_3)-	)}}}--happyReduce_17 = happySpecReduce_3  5# happyReduction_17-happyReduction_17 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut17 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 SemiColon) -> -	case happyOut16 happy_x_3 of { happy_var_3 -> -	happyIn16-		 (let (os,ss,ml) = happy_var_3 in (happy_var_1 : os, happy_var_2 : ss, Just $ ann happy_var_1 <++> nIS happy_var_2 <+?> ml)-	)}}}--happyReduce_18 = happySpecReduce_0  5# happyReduction_18-happyReduction_18  =  happyIn16-		 (([],[],Nothing)-	)--happyReduce_19 = happyReduce 4# 6# happyReduction_19-happyReduction_19 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 LANGUAGE) -> -	case happyOut18 happy_x_2 of { happy_var_2 -> -	case happyOut25 happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { (Loc happy_var_4 PragmaEnd) -> -	happyIn17-		 (LanguagePragma (happy_var_1 <^^> happy_var_4 <** (happy_var_1:snd happy_var_2 ++ reverse happy_var_3 ++ [happy_var_4])) (fst happy_var_2)-	) `HappyStk` happyRest}}}}--happyReduce_20 = happySpecReduce_3  6# happyReduction_20-happyReduction_20 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut25 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 PragmaEnd) -> -	happyIn17-		 (let Loc l (OPTIONS (mc, s)) = happy_var_1-                                                      in OptionsPragma (l <^^> happy_var_3 <** (l:reverse happy_var_2 ++ [happy_var_3])) (readTool mc) s-	)}}}--happyReduce_21 = happySpecReduce_3  6# happyReduction_21-happyReduction_21 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 ANN) -> -	case happyOut76 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 PragmaEnd) -> -	happyIn17-		 (AnnModulePragma (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3]) happy_var_2-	)}}}--happyReduce_22 = happySpecReduce_3  7# happyReduction_22-happyReduction_22 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut215 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> -	case happyOut18 happy_x_3 of { happy_var_3 -> -	happyIn18-		 ((happy_var_1 : fst happy_var_3, happy_var_2 : snd happy_var_3)-	)}}}--happyReduce_23 = happySpecReduce_1  7# happyReduction_23-happyReduction_23 happy_x_1-	 =  case happyOut215 happy_x_1 of { happy_var_1 -> -	happyIn18-		 (([happy_var_1],[])-	)}--happyReduce_24 = happySpecReduce_2  8# happyReduction_24-happyReduction_24 happy_x_2-	happy_x_1-	 =  case happyOut20 happy_x_1 of { happy_var_1 -> -	case happyOut22 happy_x_2 of { happy_var_2 -> -	happyIn19-		 (let (is,ds,ss1,inf) = happy_var_2-                 in \os ss l -> Module (l <++> inf <** (ss ++ ss1)) happy_var_1 os is ds-	)}}--happyReduce_25 = happyReduce 5# 9# happyReduction_25-happyReduction_25 (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 { (Loc happy_var_1 KW_Module) -> -	case happyOut226 happy_x_2 of { happy_var_2 -> -	case happyOut21 happy_x_3 of { happy_var_3 -> -	case happyOut26 happy_x_4 of { happy_var_4 -> -	case happyOutTok happy_x_5 of { (Loc happy_var_5 KW_Where) -> -	happyIn20-		 (Just $ ModuleHead (happy_var_1 <^^> happy_var_5 <** [happy_var_1,happy_var_5]) happy_var_2 happy_var_3 happy_var_4-	) `HappyStk` happyRest}}}}}--happyReduce_26 = happySpecReduce_0  9# happyReduction_26-happyReduction_26  =  happyIn20-		 (Nothing-	)--happyReduce_27 = happySpecReduce_3  10# happyReduction_27-happyReduction_27 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 DEPRECATED) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 PragmaEnd) -> -	happyIn21-		 (let Loc l (StringTok (s,_)) = happy_var_2 in Just $ DeprText (happy_var_1 <^^> happy_var_3 <** [happy_var_1,l,happy_var_3]) s-	)}}}--happyReduce_28 = happySpecReduce_3  10# happyReduction_28-happyReduction_28 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 WARNING) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 PragmaEnd) -> -	happyIn21-		 (let Loc l (StringTok (s,_)) = happy_var_2 in Just $ WarnText (happy_var_1 <^^> happy_var_3 <** [happy_var_1,l,happy_var_3]) s-	)}}}--happyReduce_29 = happySpecReduce_0  10# happyReduction_29-happyReduction_29  =  happyIn21-		 (Nothing-	)--happyReduce_30 = happySpecReduce_3  11# happyReduction_30-happyReduction_30 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftCurly) -> -	case happyOut23 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightCurly) -> -	happyIn22-		 (let (is,ds,ss) = happy_var_2 in (is,ds,happy_var_1:ss ++ [happy_var_3], happy_var_1 <^^> happy_var_3)-	)}}}--happyReduce_31 = happySpecReduce_3  11# happyReduction_31-happyReduction_31 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut224 happy_x_1 of { happy_var_1 -> -	case happyOut23 happy_x_2 of { happy_var_2 -> -	case happyOut225 happy_x_3 of { happy_var_3 -> -	happyIn22-		 (let (is,ds,ss) = happy_var_2 in (is,ds,happy_var_1:ss ++ [happy_var_3], happy_var_1 <^^> happy_var_3)-	)}}}--happyReduce_32 = happyReduce 4# 12# happyReduction_32-happyReduction_32 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut25 happy_x_1 of { happy_var_1 -> -	case happyOut31 happy_x_2 of { happy_var_2 -> -	case happyOut24 happy_x_3 of { happy_var_3 -> -	case happyOut48 happy_x_4 of { happy_var_4 -> -	happyIn23-		 ((reverse (fst happy_var_2), fst happy_var_4, reverse happy_var_1 ++ snd happy_var_2 ++ reverse happy_var_3 ++ snd happy_var_4)-	) `HappyStk` happyRest}}}}--happyReduce_33 = happySpecReduce_2  12# happyReduction_33-happyReduction_33 happy_x_2-	happy_x_1-	 =  case happyOut25 happy_x_1 of { happy_var_1 -> -	case happyOut48 happy_x_2 of { happy_var_2 -> -	happyIn23-		 (([], fst happy_var_2, reverse happy_var_1 ++ snd happy_var_2)-	)}}--happyReduce_34 = happySpecReduce_3  12# happyReduction_34-happyReduction_34 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut25 happy_x_1 of { happy_var_1 -> -	case happyOut31 happy_x_2 of { happy_var_2 -> -	case happyOut25 happy_x_3 of { happy_var_3 -> -	happyIn23-		 ((reverse (fst happy_var_2), [], reverse happy_var_1 ++ snd happy_var_2 ++ reverse happy_var_3)-	)}}}--happyReduce_35 = happySpecReduce_1  12# happyReduction_35-happyReduction_35 happy_x_1-	 =  case happyOut25 happy_x_1 of { happy_var_1 -> -	happyIn23-		 (([], [], reverse happy_var_1)-	)}--happyReduce_36 = happySpecReduce_2  13# happyReduction_36-happyReduction_36 happy_x_2-	happy_x_1-	 =  case happyOut25 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 SemiColon) -> -	happyIn24-		 (happy_var_2 : happy_var_1-	)}}--happyReduce_37 = happySpecReduce_1  14# happyReduction_37-happyReduction_37 happy_x_1-	 =  case happyOut24 happy_x_1 of { happy_var_1 -> -	happyIn25-		 (happy_var_1-	)}--happyReduce_38 = happySpecReduce_0  14# happyReduction_38-happyReduction_38  =  happyIn25-		 ([]-	)--happyReduce_39 = happySpecReduce_1  15# happyReduction_39-happyReduction_39 happy_x_1-	 =  case happyOut27 happy_x_1 of { happy_var_1 -> -	happyIn26-		 (Just happy_var_1-	)}--happyReduce_40 = happySpecReduce_0  15# happyReduction_40-happyReduction_40  =  happyIn26-		 (Nothing-	)--happyReduce_41 = happyReduce 4# 16# happyReduction_41-happyReduction_41 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> -	case happyOut29 happy_x_2 of { happy_var_2 -> -	case happyOut28 happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { (Loc happy_var_4 RightParen) -> -	happyIn27-		 (ExportSpecList (happy_var_1 <^^> happy_var_4 <** (happy_var_1:reverse (snd happy_var_2) ++ happy_var_3 ++ [happy_var_4])) (reverse (fst happy_var_2))-	) `HappyStk` happyRest}}}}--happyReduce_42 = happySpecReduce_3  16# happyReduction_42-happyReduction_42 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> -	case happyOut28 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> -	happyIn27-		 (ExportSpecList (happy_var_1 <^^> happy_var_3 <** (happy_var_1:happy_var_2++[happy_var_3])) []-	)}}}--happyReduce_43 = happySpecReduce_1  17# happyReduction_43-happyReduction_43 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Comma) -> -	happyIn28-		 ([happy_var_1]-	)}--happyReduce_44 = happySpecReduce_0  17# happyReduction_44-happyReduction_44  =  happyIn28-		 ([  ]-	)--happyReduce_45 = happySpecReduce_3  18# happyReduction_45-happyReduction_45 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut29 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> -	case happyOut30 happy_x_3 of { happy_var_3 -> -	happyIn29-		 ((happy_var_3 : fst happy_var_1, happy_var_2 : snd happy_var_1)-	)}}}--happyReduce_46 = happySpecReduce_1  18# happyReduction_46-happyReduction_46 happy_x_1-	 =  case happyOut30 happy_x_1 of { happy_var_1 -> -	happyIn29-		 (([happy_var_1],[])-	)}--happyReduce_47 = happySpecReduce_1  19# happyReduction_47-happyReduction_47 happy_x_1-	 =  case happyOut197 happy_x_1 of { happy_var_1 -> -	happyIn30-		 (EVar (ann happy_var_1) happy_var_1-	)}--happyReduce_48 = happySpecReduce_1  19# happyReduction_48-happyReduction_48 happy_x_1-	 =  case happyOut228 happy_x_1 of { happy_var_1 -> -	happyIn30-		 (EAbs (ann happy_var_1) happy_var_1-	)}--happyReduce_49 = happyReduce 4# 19# happyReduction_49-happyReduction_49 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut228 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftParen) -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 DotDot) -> -	case happyOutTok happy_x_4 of { (Loc happy_var_4 RightParen) -> -	happyIn30-		 (EThingAll  (ann happy_var_1 <++> nIS happy_var_4 <** [happy_var_2,happy_var_3,happy_var_4]) happy_var_1-	) `HappyStk` happyRest}}}}--happyReduce_50 = happySpecReduce_3  19# happyReduction_50-happyReduction_50 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut228 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftParen) -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> -	happyIn30-		 (EThingWith (ann happy_var_1 <++> nIS happy_var_3 <** [happy_var_2,happy_var_3])    happy_var_1 []-	)}}}--happyReduce_51 = happyReduce 4# 19# happyReduction_51-happyReduction_51 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut228 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftParen) -> -	case happyOut42 happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { (Loc happy_var_4 RightParen) -> -	happyIn30-		 (EThingWith (ann happy_var_1 <++> nIS happy_var_4 <** (happy_var_2:reverse (snd happy_var_3) ++ [happy_var_4])) happy_var_1 (reverse (fst happy_var_3))-	) `HappyStk` happyRest}}}}--happyReduce_52 = happySpecReduce_2  19# happyReduction_52-happyReduction_52 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Module) -> -	case happyOut226 happy_x_2 of { happy_var_2 -> -	happyIn30-		 (EModuleContents (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2-	)}}--happyReduce_53 = happySpecReduce_3  20# happyReduction_53-happyReduction_53 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut31 happy_x_1 of { happy_var_1 -> -	case happyOut24 happy_x_2 of { happy_var_2 -> -	case happyOut32 happy_x_3 of { happy_var_3 -> -	happyIn31-		 ((happy_var_3 : fst happy_var_1, snd happy_var_1 ++ reverse happy_var_2)-	)}}}--happyReduce_54 = happySpecReduce_1  20# happyReduction_54-happyReduction_54 happy_x_1-	 =  case happyOut32 happy_x_1 of { happy_var_1 -> -	happyIn31-		 (([happy_var_1],[])-	)}--happyReduce_55 = happyReduce 7# 21# happyReduction_55-happyReduction_55 (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 { (Loc happy_var_1 KW_Import) -> -	case happyOut33 happy_x_2 of { happy_var_2 -> -	case happyOut34 happy_x_3 of { happy_var_3 -> -	case happyOut35 happy_x_4 of { happy_var_4 -> -	case happyOut226 happy_x_5 of { happy_var_5 -> -	case happyOut36 happy_x_6 of { happy_var_6 -> -	case happyOut37 happy_x_7 of { happy_var_7 -> -	happyIn32-		 (let { (mmn,ss,ml) = happy_var_6 ;-                                      l = nIS happy_var_1 <++> ann happy_var_5 <+?> ml <+?> (fmap ann) happy_var_7 <** (happy_var_1:snd happy_var_2 ++ snd happy_var_3 ++ snd happy_var_4 ++ ss)}-                                 in ImportDecl l happy_var_5 (fst happy_var_3) (fst happy_var_2) (fst happy_var_4) mmn happy_var_7-	) `HappyStk` happyRest}}}}}}}--happyReduce_56 = happySpecReduce_2  22# happyReduction_56-happyReduction_56 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 SOURCE) -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 PragmaEnd) -> -	happyIn33-		 ((True,[happy_var_1,happy_var_2])-	)}}--happyReduce_57 = happySpecReduce_0  22# happyReduction_57-happyReduction_57  =  happyIn33-		 ((False,[])-	)--happyReduce_58 = happySpecReduce_1  23# happyReduction_58-happyReduction_58 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Qualified) -> -	happyIn34-		 ((True,[happy_var_1])-	)}--happyReduce_59 = happySpecReduce_0  23# happyReduction_59-happyReduction_59  =  happyIn34-		 ((False, [])-	)--happyReduce_60 = happyMonadReduce 1# 24# happyReduction_60-happyReduction_60 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> -	( do { checkEnabled PackageImports ;-                                                      let { Loc l (StringTok (s,_)) = happy_var_1 } ;-                                                      return $ (Just s,[l]) })}-	) (\r -> happyReturn (happyIn35 r))--happyReduce_61 = happySpecReduce_0  24# happyReduction_61-happyReduction_61  =  happyIn35-		 ((Nothing,[])-	)--happyReduce_62 = happySpecReduce_2  25# happyReduction_62-happyReduction_62 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_As) -> -	case happyOut226 happy_x_2 of { happy_var_2 -> -	happyIn36-		 ((Just happy_var_2,[happy_var_1],Just (nIS happy_var_1 <++> ann happy_var_2))-	)}}--happyReduce_63 = happySpecReduce_0  25# happyReduction_63-happyReduction_63  =  happyIn36-		 ((Nothing,[],Nothing)-	)--happyReduce_64 = happySpecReduce_1  26# happyReduction_64-happyReduction_64 happy_x_1-	 =  case happyOut38 happy_x_1 of { happy_var_1 -> -	happyIn37-		 (Just happy_var_1-	)}--happyReduce_65 = happySpecReduce_0  26# happyReduction_65-happyReduction_65  =  happyIn37-		 (Nothing-	)--happyReduce_66 = happyReduce 5# 27# happyReduction_66-happyReduction_66 (happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut39 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftParen) -> -	case happyOut40 happy_x_3 of { happy_var_3 -> -	case happyOut28 happy_x_4 of { happy_var_4 -> -	case happyOutTok happy_x_5 of { (Loc happy_var_5 RightParen) -> -	happyIn38-		 (let {(b,ml,s) = happy_var_1 ;-                                                      l = (ml <?+> (happy_var_2 <^^> happy_var_5)) <** (s ++ happy_var_2:reverse (snd happy_var_3) ++ happy_var_4 ++ [happy_var_5])}-                                                 in ImportSpecList l b (reverse (fst happy_var_3))-	) `HappyStk` happyRest}}}}}--happyReduce_67 = happyReduce 4# 27# happyReduction_67-happyReduction_67 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut39 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftParen) -> -	case happyOut28 happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { (Loc happy_var_4 RightParen) -> -	happyIn38-		 (let {(b,ml,s) = happy_var_1 ; l = (ml <?+> (happy_var_2 <^^> happy_var_4)) <** (s ++ happy_var_2:happy_var_3 ++ [happy_var_4])}-                                                 in ImportSpecList l b []-	) `HappyStk` happyRest}}}}--happyReduce_68 = happySpecReduce_1  28# happyReduction_68-happyReduction_68 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Hiding) -> -	happyIn39-		 ((True,Just (nIS happy_var_1),[happy_var_1])-	)}--happyReduce_69 = happySpecReduce_0  28# happyReduction_69-happyReduction_69  =  happyIn39-		 ((False,Nothing,[])-	)--happyReduce_70 = happySpecReduce_3  29# happyReduction_70-happyReduction_70 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut40 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> -	case happyOut41 happy_x_3 of { happy_var_3 -> -	happyIn40-		 ((happy_var_3 : fst happy_var_1, happy_var_2 : snd happy_var_1)-	)}}}--happyReduce_71 = happySpecReduce_1  29# happyReduction_71-happyReduction_71 happy_x_1-	 =  case happyOut41 happy_x_1 of { happy_var_1 -> -	happyIn40-		 (([happy_var_1],[])-	)}--happyReduce_72 = happySpecReduce_1  30# happyReduction_72-happyReduction_72 happy_x_1-	 =  case happyOut195 happy_x_1 of { happy_var_1 -> -	happyIn41-		 (IVar (ann happy_var_1) happy_var_1-	)}--happyReduce_73 = happySpecReduce_1  30# happyReduction_73-happyReduction_73 happy_x_1-	 =  case happyOut227 happy_x_1 of { happy_var_1 -> -	happyIn41-		 (IAbs (ann happy_var_1) happy_var_1-	)}--happyReduce_74 = happyReduce 4# 30# happyReduction_74-happyReduction_74 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut227 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftParen) -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 DotDot) -> -	case happyOutTok happy_x_4 of { (Loc happy_var_4 RightParen) -> -	happyIn41-		 (IThingAll  (ann happy_var_1 <++> nIS happy_var_4 <** [happy_var_2,happy_var_3,happy_var_4]) happy_var_1-	) `HappyStk` happyRest}}}}--happyReduce_75 = happySpecReduce_3  30# happyReduction_75-happyReduction_75 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut227 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftParen) -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> -	happyIn41-		 (IThingWith (ann happy_var_1 <++> nIS happy_var_3 <** [happy_var_2,happy_var_3])    happy_var_1 []-	)}}}--happyReduce_76 = happyReduce 4# 30# happyReduction_76-happyReduction_76 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut227 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftParen) -> -	case happyOut42 happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { (Loc happy_var_4 RightParen) -> -	happyIn41-		 (IThingWith (ann happy_var_1 <++> nIS happy_var_4 <** (happy_var_2:reverse (snd happy_var_3) ++ [happy_var_4])) happy_var_1 (reverse (fst happy_var_3))-	) `HappyStk` happyRest}}}}--happyReduce_77 = happySpecReduce_3  31# happyReduction_77-happyReduction_77 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut42 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> -	case happyOut43 happy_x_3 of { happy_var_3 -> -	happyIn42-		 ((happy_var_3 : fst happy_var_1, happy_var_2 : snd happy_var_1)-	)}}}--happyReduce_78 = happySpecReduce_1  31# happyReduction_78-happyReduction_78 happy_x_1-	 =  case happyOut43 happy_x_1 of { happy_var_1 -> -	happyIn42-		 (([happy_var_1],[])-	)}--happyReduce_79 = happySpecReduce_1  32# happyReduction_79-happyReduction_79 happy_x_1-	 =  case happyOut195 happy_x_1 of { happy_var_1 -> -	happyIn43-		 (VarName (ann happy_var_1) happy_var_1-	)}--happyReduce_80 = happySpecReduce_1  32# happyReduction_80-happyReduction_80 happy_x_1-	 =  case happyOut199 happy_x_1 of { happy_var_1 -> -	happyIn43-		 (ConName (ann happy_var_1) happy_var_1-	)}--happyReduce_81 = happySpecReduce_3  33# happyReduction_81-happyReduction_81 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut46 happy_x_1 of { happy_var_1 -> -	case happyOut45 happy_x_2 of { happy_var_2 -> -	case happyOut47 happy_x_3 of { happy_var_3 -> -	happyIn44-		 (let (ops,ss,l) = happy_var_3-                                                 in InfixDecl (ann happy_var_1 <++> l <** (snd happy_var_2 ++ reverse ss)) happy_var_1 (fst happy_var_2) (reverse ops)-	)}}}--happyReduce_82 = happySpecReduce_0  34# happyReduction_82-happyReduction_82  =  happyIn45-		 ((Nothing, [])-	)--happyReduce_83 = happyMonadReduce 1# 34# happyReduction_83-happyReduction_83 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> -	( let Loc l (IntTok (i,_)) = happy_var_1 in checkPrec i >>= \i -> return (Just i, [l]))}-	) (\r -> happyReturn (happyIn45 r))--happyReduce_84 = happySpecReduce_1  35# happyReduction_84-happyReduction_84 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Infix) -> -	happyIn46-		 (AssocNone  $ nIS happy_var_1-	)}--happyReduce_85 = happySpecReduce_1  35# happyReduction_85-happyReduction_85 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_InfixL) -> -	happyIn46-		 (AssocLeft  $ nIS happy_var_1-	)}--happyReduce_86 = happySpecReduce_1  35# happyReduction_86-happyReduction_86 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_InfixR) -> -	happyIn46-		 (AssocRight $ nIS happy_var_1-	)}--happyReduce_87 = happySpecReduce_3  36# happyReduction_87-happyReduction_87 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut47 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> -	case happyOut206 happy_x_3 of { happy_var_3 -> -	happyIn47-		 (let (ops,ss,l) = happy_var_1 in (happy_var_3 : ops, happy_var_2 : ss, l <++> ann happy_var_3)-	)}}}--happyReduce_88 = happySpecReduce_1  36# happyReduction_88-happyReduction_88 happy_x_1-	 =  case happyOut206 happy_x_1 of { happy_var_1 -> -	happyIn47-		 (([happy_var_1],[],ann happy_var_1)-	)}--happyReduce_89 = happyMonadReduce 2# 37# happyReduction_89-happyReduction_89 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut49 happy_x_1 of { happy_var_1 -> -	case happyOut25 happy_x_2 of { happy_var_2 -> -	( checkRevDecls (fst happy_var_1) >>= \ds -> return (ds, snd happy_var_1 ++ reverse happy_var_2))}}-	) (\r -> happyReturn (happyIn48 r))--happyReduce_90 = happySpecReduce_3  38# happyReduction_90-happyReduction_90 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut49 happy_x_1 of { happy_var_1 -> -	case happyOut24 happy_x_2 of { happy_var_2 -> -	case happyOut50 happy_x_3 of { happy_var_3 -> -	happyIn49-		 ((happy_var_3 : fst happy_var_1, snd happy_var_1 ++ reverse happy_var_2)-	)}}}--happyReduce_91 = happySpecReduce_1  38# happyReduction_91-happyReduction_91 happy_x_1-	 =  case happyOut50 happy_x_1 of { happy_var_1 -> -	happyIn49-		 (([happy_var_1],[])-	)}--happyReduce_92 = happyMonadReduce 4# 39# happyReduction_92-happyReduction_92 (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 { (Loc happy_var_1 KW_Type) -> -	case happyOut78 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 Equals) -> -	case happyOut88 happy_x_4 of { happy_var_4 -> -	( do { dh <- checkSimpleType happy_var_2;-                       let {l = nIS happy_var_1 <++> ann happy_var_4 <** [happy_var_1,happy_var_3]};-                       return (TypeDecl l dh happy_var_4) })}}}}-	) (\r -> happyReturn (happyIn50 r))--happyReduce_93 = happyMonadReduce 4# 39# happyReduction_93-happyReduction_93 (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 { (Loc happy_var_1 KW_Type) -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 KW_Family) -> -	case happyOut80 happy_x_3 of { happy_var_3 -> -	case happyOut122 happy_x_4 of { happy_var_4 -> -	( do { dh <- checkSimpleType happy_var_3;-                       let {l = nIS happy_var_1 <++> ann happy_var_3 <+?> (fmap ann) (fst happy_var_4) <** (happy_var_1:happy_var_2:snd happy_var_4)};-                       return (TypeFamDecl l dh (fst happy_var_4)) })}}}}-	) (\r -> happyReturn (happyIn50 r))--happyReduce_94 = happyMonadReduce 5# 39# happyReduction_94-happyReduction_94 (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 { (Loc happy_var_1 KW_Type) -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 KW_Instance) -> -	case happyOut77 happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { (Loc happy_var_4 Equals) -> -	case happyOut88 happy_x_5 of { happy_var_5 -> -	( do { -- no checkSimpleType happy_var_4 since dtype may contain type patterns-                       checkEnabled TypeFamilies ;-                       let {l = nIS happy_var_1 <++> ann happy_var_5 <** [happy_var_1,happy_var_2,happy_var_4]};-                       return (TypeInsDecl l happy_var_3 happy_var_5) })}}}}}-	) (\r -> happyReturn (happyIn50 r))--happyReduce_95 = happyMonadReduce 4# 39# happyReduction_95-happyReduction_95 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut51 happy_x_1 of { happy_var_1 -> -	case happyOut89 happy_x_2 of { happy_var_2 -> -	case happyOut104 happy_x_3 of { happy_var_3 -> -	case happyOut116 happy_x_4 of { happy_var_4 -> -	( do { (cs,dh) <- checkDataHeader happy_var_2;-                       let { (qds,ss,minf) = happy_var_3;-                             l = happy_var_1 <> happy_var_2 <+?> minf <+?> fmap ann happy_var_4 <** ss};-                       checkDataOrNew happy_var_1 qds;-                       return (DataDecl l happy_var_1 cs dh (reverse qds) happy_var_4) })}}}}-	) (\r -> happyReturn (happyIn50 r))--happyReduce_96 = happyMonadReduce 5# 39# 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) tk-	 = happyThen (case happyOut51 happy_x_1 of { happy_var_1 -> -	case happyOut89 happy_x_2 of { happy_var_2 -> -	case happyOut122 happy_x_3 of { happy_var_3 -> -	case happyOut100 happy_x_4 of { happy_var_4 -> -	case happyOut116 happy_x_5 of { happy_var_5 -> -	( do { (cs,dh) <- checkDataHeader happy_var_2;-                       let { (gs,ss,minf) = happy_var_4;-                             l = ann happy_var_1 <+?> minf <+?> fmap ann happy_var_5 <** (snd happy_var_3 ++ ss)};-                       checkDataOrNewG happy_var_1 gs;-                       case (gs, fst happy_var_3) of-                        ([], Nothing) -> return (DataDecl l happy_var_1 cs dh [] happy_var_5)-                        _ -> checkEnabled GADTs >> return (GDataDecl l happy_var_1 cs dh (fst happy_var_3) (reverse gs) happy_var_5) })}}}}}-	) (\r -> happyReturn (happyIn50 r))--happyReduce_97 = happyMonadReduce 4# 39# happyReduction_97-happyReduction_97 (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 { (Loc happy_var_1 KW_Data) -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 KW_Family) -> -	case happyOut89 happy_x_3 of { happy_var_3 -> -	case happyOut122 happy_x_4 of { happy_var_4 -> -	( do { (cs,dh) <- checkDataHeader happy_var_3;-                       let {l = nIS happy_var_1 <++> ann happy_var_3 <+?> (fmap ann) (fst happy_var_4) <** (happy_var_1:happy_var_2:snd happy_var_4)};-                       return (DataFamDecl l cs dh (fst happy_var_4)) })}}}}-	) (\r -> happyReturn (happyIn50 r))--happyReduce_98 = happyMonadReduce 5# 39# happyReduction_98-happyReduction_98 (happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut51 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 KW_Instance) -> -	case happyOut88 happy_x_3 of { happy_var_3 -> -	case happyOut104 happy_x_4 of { happy_var_4 -> -	case happyOut116 happy_x_5 of { happy_var_5 -> -	( do { -- (cs,c,t) <- checkDataHeader happy_var_4;-                       checkEnabled TypeFamilies ;-                       let { (qds,ss,minf) = happy_var_4 ;-                             l = happy_var_1 <> happy_var_3 <+?> minf <+?> fmap ann happy_var_5 <** happy_var_2:ss };-                       checkDataOrNew happy_var_1 qds;-                       return (DataInsDecl l happy_var_1 happy_var_3 (reverse qds) happy_var_5) })}}}}}-	) (\r -> happyReturn (happyIn50 r))--happyReduce_99 = happyMonadReduce 6# 39# happyReduction_99-happyReduction_99 (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 happyOut51 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 KW_Instance) -> -	case happyOut88 happy_x_3 of { happy_var_3 -> -	case happyOut122 happy_x_4 of { happy_var_4 -> -	case happyOut100 happy_x_5 of { happy_var_5 -> -	case happyOut116 happy_x_6 of { happy_var_6 -> -	( do { -- (cs,c,t) <- checkDataHeader happy_var_4;-                       checkEnabled TypeFamilies ;-                       let {(gs,ss,minf) = happy_var_5;-                            l = ann happy_var_1 <+?> minf <+?> fmap ann happy_var_6 <** (happy_var_2:snd happy_var_4 ++ ss)};-                       checkDataOrNewG happy_var_1 gs;-                       return (GDataInsDecl l happy_var_1 happy_var_3 (fst happy_var_4) (reverse gs) happy_var_6) })}}}}}}-	) (\r -> happyReturn (happyIn50 r))--happyReduce_100 = happyMonadReduce 4# 39# happyReduction_100-happyReduction_100 (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 { (Loc happy_var_1 KW_Class) -> -	case happyOut89 happy_x_2 of { happy_var_2 -> -	case happyOut97 happy_x_3 of { happy_var_3 -> -	case happyOut123 happy_x_4 of { happy_var_4 -> -	( do { (cs,dh) <- checkClassHeader happy_var_2;-                       let {(fds,ss1,minf1) = happy_var_3;(mcs,ss2,minf2) = happy_var_4} ;-                       let { l = nIS happy_var_1 <++> ann happy_var_2 <+?> minf1 <+?> minf2 <** (happy_var_1:ss1 ++ ss2)} ;-                       return (ClassDecl l cs dh fds mcs) })}}}}-	) (\r -> happyReturn (happyIn50 r))--happyReduce_101 = happyMonadReduce 3# 39# happyReduction_101-happyReduction_101 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Instance) -> -	case happyOut89 happy_x_2 of { happy_var_2 -> -	case happyOut128 happy_x_3 of { happy_var_3 -> -	( do { (cs,ih) <- checkInstHeader happy_var_2;-                       let {(mis,ss,minf) = happy_var_3};-                       return (InstDecl (nIS happy_var_1 <++> ann happy_var_2 <+?> minf <** (happy_var_1:ss)) cs ih mis) })}}}-	) (\r -> happyReturn (happyIn50 r))--happyReduce_102 = happyMonadReduce 3# 39# happyReduction_102-happyReduction_102 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Deriving) -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 KW_Instance) -> -	case happyOut89 happy_x_3 of { happy_var_3 -> -	( do { checkEnabled StandaloneDeriving ;-                       (cs, ih) <- checkInstHeader happy_var_3;-                       let {l = nIS happy_var_1 <++> ann happy_var_3 <** [happy_var_1,happy_var_2]};-                       return (DerivDecl l cs ih) })}}}-	) (\r -> happyReturn (happyIn50 r))--happyReduce_103 = happyReduce 4# 39# happyReduction_103-happyReduction_103 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Default) -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftParen) -> -	case happyOut52 happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { (Loc happy_var_4 RightParen) -> -	happyIn50-		 (DefaultDecl (happy_var_1 <^^> happy_var_4 <** (happy_var_1:happy_var_2 : snd happy_var_3 ++ [happy_var_4])) (fst happy_var_3)-	) `HappyStk` happyRest}}}}--happyReduce_104 = happyMonadReduce 1# 39# happyReduction_104-happyReduction_104 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut141 happy_x_1 of { happy_var_1 -> -	( checkEnabled TemplateHaskell >> checkExpr happy_var_1 >>= \e -> return (SpliceDecl (ann e) e))}-	) (\r -> happyReturn (happyIn50 r))--happyReduce_105 = happyReduce 5# 39# 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 happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Foreign) -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 KW_Import) -> -	case happyOut63 happy_x_3 of { happy_var_3 -> -	case happyOut64 happy_x_4 of { happy_var_4 -> -	case happyOut65 happy_x_5 of { happy_var_5 -> -	happyIn50-		 (let (s,n,t,ss) = happy_var_5 in ForImp (nIS happy_var_1 <++> ann t <** (happy_var_1:happy_var_2:ss)) happy_var_3 happy_var_4 s n t-	) `HappyStk` happyRest}}}}}--happyReduce_106 = happyReduce 4# 39# happyReduction_106-happyReduction_106 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Foreign) -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 KW_Export) -> -	case happyOut63 happy_x_3 of { happy_var_3 -> -	case happyOut65 happy_x_4 of { happy_var_4 -> -	happyIn50-		 (let (s,n,t,ss) = happy_var_4 in ForExp (nIS happy_var_1 <++> ann t <** (happy_var_1:happy_var_2:ss)) happy_var_3    s n t-	) `HappyStk` happyRest}}}}--happyReduce_107 = happySpecReduce_3  39# happyReduction_107-happyReduction_107 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 RULES) -> -	case happyOut66 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 PragmaEnd) -> -	happyIn50-		 (RulePragmaDecl (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3]) $ reverse happy_var_2-	)}}}--happyReduce_108 = happySpecReduce_3  39# happyReduction_108-happyReduction_108 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 DEPRECATED) -> -	case happyOut72 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 PragmaEnd) -> -	happyIn50-		 (DeprPragmaDecl (happy_var_1 <^^> happy_var_3 <** (happy_var_1:snd happy_var_2++[happy_var_3])) $ reverse (fst happy_var_2)-	)}}}--happyReduce_109 = happySpecReduce_3  39# happyReduction_109-happyReduction_109 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 WARNING) -> -	case happyOut72 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 PragmaEnd) -> -	happyIn50-		 (WarnPragmaDecl (happy_var_1 <^^> happy_var_3 <** (happy_var_1:snd happy_var_2++[happy_var_3])) $ reverse (fst happy_var_2)-	)}}}--happyReduce_110 = happySpecReduce_3  39# happyReduction_110-happyReduction_110 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 ANN) -> -	case happyOut76 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 PragmaEnd) -> -	happyIn50-		 (AnnPragma      (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3]) happy_var_2-	)}}}--happyReduce_111 = happySpecReduce_1  39# happyReduction_111-happyReduction_111 happy_x_1-	 =  case happyOut55 happy_x_1 of { happy_var_1 -> -	happyIn50-		 (happy_var_1-	)}--happyReduce_112 = happySpecReduce_1  40# happyReduction_112-happyReduction_112 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Data) -> -	happyIn51-		 (DataType $ nIS happy_var_1-	)}--happyReduce_113 = happySpecReduce_1  40# happyReduction_113-happyReduction_113 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_NewType) -> -	happyIn51-		 (NewType  $ nIS happy_var_1-	)}--happyReduce_114 = happyMonadReduce 1# 41# happyReduction_114-happyReduction_114 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut91 happy_x_1 of { happy_var_1 -> -	( do { ts <- mapM checkType (fst happy_var_1);-                                              return $ (reverse ts, reverse (snd happy_var_1)) })}-	) (\r -> happyReturn (happyIn52 r))--happyReduce_115 = happySpecReduce_1  41# happyReduction_115-happyReduction_115 happy_x_1-	 =  case happyOut79 happy_x_1 of { happy_var_1 -> -	happyIn52-		 (([happy_var_1],[])-	)}--happyReduce_116 = happySpecReduce_0  41# happyReduction_116-happyReduction_116  =  happyIn52-		 (([],[])-	)--happyReduce_117 = happyMonadReduce 3# 42# happyReduction_117-happyReduction_117 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut25 happy_x_1 of { happy_var_1 -> -	case happyOut54 happy_x_2 of { happy_var_2 -> -	case happyOut25 happy_x_3 of { happy_var_3 -> -	( checkRevDecls (fst happy_var_2) >>= \ds -> return (ds, reverse happy_var_1 ++ snd happy_var_2 ++ reverse happy_var_3))}}}-	) (\r -> happyReturn (happyIn53 r))--happyReduce_118 = happySpecReduce_1  42# happyReduction_118-happyReduction_118 happy_x_1-	 =  case happyOut25 happy_x_1 of { happy_var_1 -> -	happyIn53-		 (([],reverse happy_var_1)-	)}--happyReduce_119 = happySpecReduce_3  43# happyReduction_119-happyReduction_119 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut54 happy_x_1 of { happy_var_1 -> -	case happyOut24 happy_x_2 of { happy_var_2 -> -	case happyOut55 happy_x_3 of { happy_var_3 -> -	happyIn54-		 ((happy_var_3 : fst happy_var_1, snd happy_var_1 ++ reverse happy_var_2)-	)}}}--happyReduce_120 = happySpecReduce_1  43# happyReduction_120-happyReduction_120 happy_x_1-	 =  case happyOut55 happy_x_1 of { happy_var_1 -> -	happyIn54-		 (([happy_var_1],[])-	)}--happyReduce_121 = happySpecReduce_1  44# happyReduction_121-happyReduction_121 happy_x_1-	 =  case happyOut57 happy_x_1 of { happy_var_1 -> -	happyIn55-		 (happy_var_1-	)}--happyReduce_122 = happySpecReduce_1  44# happyReduction_122-happyReduction_122 happy_x_1-	 =  case happyOut44 happy_x_1 of { happy_var_1 -> -	happyIn55-		 (happy_var_1-	)}--happyReduce_123 = happySpecReduce_1  44# happyReduction_123-happyReduction_123 happy_x_1-	 =  case happyOut133 happy_x_1 of { happy_var_1 -> -	happyIn55-		 (happy_var_1-	)}--happyReduce_124 = happySpecReduce_3  45# happyReduction_124-happyReduction_124 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftCurly) -> -	case happyOut53 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightCurly) -> -	happyIn56-		 (BDecls (happy_var_1 <^^> happy_var_3 <** (happy_var_1:snd happy_var_2++[happy_var_3])) (fst happy_var_2)-	)}}}--happyReduce_125 = happySpecReduce_3  45# happyReduction_125-happyReduction_125 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut224 happy_x_1 of { happy_var_1 -> -	case happyOut53 happy_x_2 of { happy_var_2 -> -	case happyOut225 happy_x_3 of { happy_var_3 -> -	happyIn56-		 (BDecls (happy_var_1 <^^> happy_var_3 <** (happy_var_1:snd happy_var_2++[happy_var_3])) (fst happy_var_2)-	)}}}--happyReduce_126 = happyMonadReduce 3# 46# happyReduction_126-happyReduction_126 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut143 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 DoubleColon) -> -	case happyOut88 happy_x_3 of { happy_var_3 -> -	( do { v <- checkSigVar happy_var_1;-                                                               return $ TypeSig (happy_var_1 <> happy_var_3 <** [happy_var_2]) [v] happy_var_3 })}}}-	) (\r -> happyReturn (happyIn57 r))--happyReduce_127 = happyMonadReduce 5# 46# happyReduction_127-happyReduction_127 (happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut143 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> -	case happyOut62 happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { (Loc happy_var_4 DoubleColon) -> -	case happyOut88 happy_x_5 of { happy_var_5 -> -	( do { v <- checkSigVar happy_var_1;-                                                               let {(vs,ss,_) = happy_var_3 ; l = happy_var_1 <> happy_var_5 <** (happy_var_2 : reverse ss ++ [happy_var_4]) } ;-                                                               return $ TypeSig l (v : reverse vs) happy_var_5 })}}}}}-	) (\r -> happyReturn (happyIn57 r))--happyReduce_128 = happySpecReduce_1  46# happyReduction_128-happyReduction_128 happy_x_1-	 =  case happyOut58 happy_x_1 of { happy_var_1 -> -	happyIn57-		 (happy_var_1-	)}--happyReduce_129 = happyReduce 4# 47# happyReduction_129-happyReduction_129 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut68 happy_x_2 of { happy_var_2 -> -	case happyOut197 happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { (Loc happy_var_4 PragmaEnd) -> -	happyIn58-		 (let Loc l (INLINE s) = happy_var_1 in InlineSig (l <^^> happy_var_4 <** [l,happy_var_4]) s happy_var_2 happy_var_3-	) `HappyStk` happyRest}}}}--happyReduce_130 = happyReduce 4# 47# happyReduction_130-happyReduction_130 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 INLINE_CONLIKE) -> -	case happyOut68 happy_x_2 of { happy_var_2 -> -	case happyOut197 happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { (Loc happy_var_4 PragmaEnd) -> -	happyIn58-		 (InlineConlikeSig (happy_var_1 <^^> happy_var_4 <** [happy_var_1,happy_var_4]) happy_var_2 happy_var_3-	) `HappyStk` happyRest}}}}--happyReduce_131 = happyReduce 5# 47# happyReduction_131-happyReduction_131 (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 { (Loc happy_var_1 SPECIALISE) -> -	case happyOut197 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 DoubleColon) -> -	case happyOut59 happy_x_4 of { happy_var_4 -> -	case happyOutTok happy_x_5 of { (Loc happy_var_5 PragmaEnd) -> -	happyIn58-		 (SpecSig (happy_var_1 <^^> happy_var_5 <** (happy_var_1:happy_var_3 : snd happy_var_4 ++ [happy_var_5])) happy_var_2 (fst happy_var_4)-	) `HappyStk` happyRest}}}}}--happyReduce_132 = happyReduce 6# 47# happyReduction_132-happyReduction_132 (happy_x_6 `HappyStk`-	happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut68 happy_x_2 of { happy_var_2 -> -	case happyOut197 happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { (Loc happy_var_4 DoubleColon) -> -	case happyOut59 happy_x_5 of { happy_var_5 -> -	case happyOutTok happy_x_6 of { (Loc happy_var_6 PragmaEnd) -> -	happyIn58-		 (let Loc l (SPECIALISE_INLINE s) = happy_var_1-                                                          in SpecInlineSig (l <^^> happy_var_6 <** (l:happy_var_4:snd happy_var_5++[happy_var_6])) s happy_var_2 happy_var_3 (fst happy_var_5)-	) `HappyStk` happyRest}}}}}}--happyReduce_133 = happyMonadReduce 4# 47# happyReduction_133-happyReduction_133 (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 { (Loc happy_var_1 SPECIALISE) -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 KW_Instance) -> -	case happyOut89 happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { (Loc happy_var_4 PragmaEnd) -> -	( do { (cs,ih) <- checkInstHeader happy_var_3;-                                                               let {l = happy_var_1 <^^> happy_var_4 <** [happy_var_1,happy_var_2,happy_var_4]};-                                                               return $ InstSig l cs ih })}}}}-	) (\r -> happyReturn (happyIn58 r))--happyReduce_134 = happySpecReduce_1  48# happyReduction_134-happyReduction_134 happy_x_1-	 =  case happyOut60 happy_x_1 of { happy_var_1 -> -	happyIn59-		 (([happy_var_1],[])-	)}--happyReduce_135 = happySpecReduce_3  48# happyReduction_135-happyReduction_135 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut60 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> -	case happyOut59 happy_x_3 of { happy_var_3 -> -	happyIn59-		 ((happy_var_1 : fst happy_var_3, happy_var_2 : snd happy_var_3)-	)}}}--happyReduce_136 = happyMonadReduce 1# 49# happyReduction_136-happyReduction_136 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut89 happy_x_1 of { happy_var_1 -> -	( checkType $ mkTyForall (ann happy_var_1) Nothing Nothing happy_var_1)}-	) (\r -> happyReturn (happyIn60 r))--happyReduce_137 = happySpecReduce_1  50# happyReduction_137-happyReduction_137 happy_x_1-	 =  case happyOut56 happy_x_1 of { happy_var_1 -> -	happyIn61-		 (happy_var_1-	)}--happyReduce_138 = happySpecReduce_3  50# happyReduction_138-happyReduction_138 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftCurly) -> -	case happyOut191 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightCurly) -> -	happyIn61-		 (IPBinds (happy_var_1 <^^> happy_var_3 <** snd happy_var_2) (fst happy_var_2)-	)}}}--happyReduce_139 = happySpecReduce_3  50# happyReduction_139-happyReduction_139 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut224 happy_x_1 of { happy_var_1 -> -	case happyOut191 happy_x_2 of { happy_var_2 -> -	case happyOut225 happy_x_3 of { happy_var_3 -> -	happyIn61-		 (IPBinds (happy_var_1 <^^> happy_var_3 <** snd happy_var_2) (fst happy_var_2)-	)}}}--happyReduce_140 = happySpecReduce_3  51# happyReduction_140-happyReduction_140 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut62 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> -	case happyOut195 happy_x_3 of { happy_var_3 -> -	happyIn62-		 (let (ns,ss,l) = happy_var_1 in (happy_var_3 : ns, happy_var_2 : ss, l <++> ann happy_var_3)-	)}}}--happyReduce_141 = happyMonadReduce 1# 51# happyReduction_141-happyReduction_141 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut197 happy_x_1 of { happy_var_1 -> -	( do { n <- checkUnQual happy_var_1;-                                              return ([n],[],ann n) })}-	) (\r -> happyReturn (happyIn62 r))--happyReduce_142 = happySpecReduce_1  52# happyReduction_142-happyReduction_142 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_StdCall) -> -	happyIn63-		 (StdCall   (nIS happy_var_1)-	)}--happyReduce_143 = happySpecReduce_1  52# happyReduction_143-happyReduction_143 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_CCall) -> -	happyIn63-		 (CCall     (nIS happy_var_1)-	)}--happyReduce_144 = happySpecReduce_1  52# happyReduction_144-happyReduction_144 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_CPlusPlus) -> -	happyIn63-		 (CPlusPlus (nIS happy_var_1)-	)}--happyReduce_145 = happySpecReduce_1  52# happyReduction_145-happyReduction_145 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_DotNet) -> -	happyIn63-		 (DotNet    (nIS happy_var_1)-	)}--happyReduce_146 = happySpecReduce_1  52# happyReduction_146-happyReduction_146 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Jvm) -> -	happyIn63-		 (Jvm       (nIS happy_var_1)-	)}--happyReduce_147 = happySpecReduce_1  52# happyReduction_147-happyReduction_147 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Js) -> -	happyIn63-		 (Js        (nIS happy_var_1)-	)}--happyReduce_148 = happySpecReduce_1  53# happyReduction_148-happyReduction_148 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Safe) -> -	happyIn64-		 (Just $ PlaySafe  (nIS happy_var_1) False-	)}--happyReduce_149 = happySpecReduce_1  53# happyReduction_149-happyReduction_149 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Unsafe) -> -	happyIn64-		 (Just $ PlayRisky (nIS happy_var_1)-	)}--happyReduce_150 = happySpecReduce_1  53# happyReduction_150-happyReduction_150 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Threadsafe) -> -	happyIn64-		 (Just $ PlaySafe  (nIS happy_var_1) True-	)}--happyReduce_151 = happySpecReduce_0  53# happyReduction_151-happyReduction_151  =  happyIn64-		 (Nothing-	)--happyReduce_152 = happyReduce 4# 54# happyReduction_152-happyReduction_152 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut196 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 DoubleColon) -> -	case happyOut77 happy_x_4 of { happy_var_4 -> -	happyIn65-		 (let Loc l (StringTok (s,_)) = happy_var_1 in (Just s, happy_var_2, happy_var_4, [l,happy_var_3])-	) `HappyStk` happyRest}}}}--happyReduce_153 = happySpecReduce_3  54# happyReduction_153-happyReduction_153 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut196 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 DoubleColon) -> -	case happyOut77 happy_x_3 of { happy_var_3 -> -	happyIn65-		 ((Nothing, happy_var_1, happy_var_3, [happy_var_2])-	)}}}--happyReduce_154 = happySpecReduce_3  55# happyReduction_154-happyReduction_154 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut66 happy_x_1 of { happy_var_1 -> -	case happyOut67 happy_x_3 of { happy_var_3 -> -	happyIn66-		 (happy_var_3 : happy_var_1-	)}}--happyReduce_155 = happySpecReduce_2  55# happyReduction_155-happyReduction_155 happy_x_2-	happy_x_1-	 =  case happyOut66 happy_x_1 of { happy_var_1 -> -	happyIn66-		 (happy_var_1-	)}--happyReduce_156 = happySpecReduce_1  55# happyReduction_156-happyReduction_156 happy_x_1-	 =  case happyOut67 happy_x_1 of { happy_var_1 -> -	happyIn66-		 ([happy_var_1]-	)}--happyReduce_157 = happySpecReduce_0  55# happyReduction_157-happyReduction_157  =  happyIn66-		 ([]-	)--happyReduce_158 = happyMonadReduce 6# 56# happyReduction_158-happyReduction_158 (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 { happy_var_1 -> -	case happyOut68 happy_x_2 of { happy_var_2 -> -	case happyOut69 happy_x_3 of { happy_var_3 -> -	case happyOut141 happy_x_4 of { happy_var_4 -> -	case happyOutTok happy_x_5 of { (Loc happy_var_5 Equals) -> -	case happyOut139 happy_x_6 of { happy_var_6 -> -	( do { let {Loc l (StringTok (s,_)) = happy_var_1};-                                                                  e <- checkRuleExpr happy_var_4;-                                                                  return $ Rule (nIS l <++> ann happy_var_6 <** l:snd happy_var_3 ++ [happy_var_5]) s happy_var_2 (fst happy_var_3) e happy_var_6 })}}}}}}-	) (\r -> happyReturn (happyIn67 r))--happyReduce_159 = happySpecReduce_0  57# happyReduction_159-happyReduction_159  =  happyIn68-		 (Nothing-	)--happyReduce_160 = happySpecReduce_3  57# happyReduction_160-happyReduction_160 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftSquare) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightSquare) -> -	happyIn68-		 (let Loc l (IntTok (i,_)) = happy_var_2 in Just $ ActiveFrom  (happy_var_1 <^^> happy_var_3 <** [happy_var_1,l,happy_var_3])    (fromInteger i)-	)}}}--happyReduce_161 = happyReduce 4# 57# happyReduction_161-happyReduction_161 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftSquare) -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 Tilde) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { (Loc happy_var_4 RightSquare) -> -	happyIn68-		 (let Loc l (IntTok (i,_)) = happy_var_3 in Just $ ActiveUntil (happy_var_1 <^^> happy_var_4 <** [happy_var_1,happy_var_2,l,happy_var_4]) (fromInteger i)-	) `HappyStk` happyRest}}}}--happyReduce_162 = happySpecReduce_0  58# happyReduction_162-happyReduction_162  =  happyIn69-		 ((Nothing,[])-	)--happyReduce_163 = happySpecReduce_3  58# happyReduction_163-happyReduction_163 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Forall) -> -	case happyOut70 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 Dot) -> -	happyIn69-		 ((Just happy_var_2,[happy_var_1,happy_var_3])-	)}}}--happyReduce_164 = happySpecReduce_1  59# happyReduction_164-happyReduction_164 happy_x_1-	 =  case happyOut71 happy_x_1 of { happy_var_1 -> -	happyIn70-		 ([happy_var_1]-	)}--happyReduce_165 = happySpecReduce_2  59# happyReduction_165-happyReduction_165 happy_x_2-	happy_x_1-	 =  case happyOut71 happy_x_1 of { happy_var_1 -> -	case happyOut70 happy_x_2 of { happy_var_2 -> -	happyIn70-		 (happy_var_1 : happy_var_2-	)}}--happyReduce_166 = happySpecReduce_1  60# happyReduction_166-happyReduction_166 happy_x_1-	 =  case happyOut212 happy_x_1 of { happy_var_1 -> -	happyIn71-		 (RuleVar (ann happy_var_1) happy_var_1-	)}--happyReduce_167 = happyReduce 5# 60# happyReduction_167-happyReduction_167 (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 { (Loc happy_var_1 LeftParen) -> -	case happyOut212 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 DoubleColon) -> -	case happyOut88 happy_x_4 of { happy_var_4 -> -	case happyOutTok happy_x_5 of { (Loc happy_var_5 RightParen) -> -	happyIn71-		 (TypedRuleVar (happy_var_1 <^^> happy_var_5 <** [happy_var_1,happy_var_3,happy_var_5]) happy_var_2 happy_var_4-	) `HappyStk` happyRest}}}}}--happyReduce_168 = happySpecReduce_3  61# happyReduction_168-happyReduction_168 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut72 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 SemiColon) -> -	case happyOut73 happy_x_3 of { happy_var_3 -> -	happyIn72-		 ((fst happy_var_3 : fst happy_var_1, snd happy_var_1 ++ (happy_var_2:snd happy_var_3))-	)}}}--happyReduce_169 = happySpecReduce_2  61# happyReduction_169-happyReduction_169 happy_x_2-	happy_x_1-	 =  case happyOut72 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 SemiColon) -> -	happyIn72-		 ((fst happy_var_1, snd happy_var_1 ++ [happy_var_2])-	)}}--happyReduce_170 = happySpecReduce_1  61# happyReduction_170-happyReduction_170 happy_x_1-	 =  case happyOut73 happy_x_1 of { happy_var_1 -> -	happyIn72-		 (([fst happy_var_1],snd happy_var_1)-	)}--happyReduce_171 = happySpecReduce_0  61# happyReduction_171-happyReduction_171  =  happyIn72-		 (([],[])-	)--happyReduce_172 = happySpecReduce_2  62# happyReduction_172-happyReduction_172 happy_x_2-	happy_x_1-	 =  case happyOut74 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	happyIn73-		 (let Loc l (StringTok (s,_)) = happy_var_2 in ((fst happy_var_1,s),snd happy_var_1 ++ [l])-	)}}--happyReduce_173 = happySpecReduce_1  63# happyReduction_173-happyReduction_173 happy_x_1-	 =  case happyOut75 happy_x_1 of { happy_var_1 -> -	happyIn74-		 (([happy_var_1],[])-	)}--happyReduce_174 = happySpecReduce_3  63# happyReduction_174-happyReduction_174 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut75 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> -	case happyOut74 happy_x_3 of { happy_var_3 -> -	happyIn74-		 ((happy_var_1 : fst happy_var_3, happy_var_2 : snd happy_var_3)-	)}}}--happyReduce_175 = happySpecReduce_1  64# happyReduction_175-happyReduction_175 happy_x_1-	 =  case happyOut199 happy_x_1 of { happy_var_1 -> -	happyIn75-		 (happy_var_1-	)}--happyReduce_176 = happySpecReduce_1  64# happyReduction_176-happyReduction_176 happy_x_1-	 =  case happyOut195 happy_x_1 of { happy_var_1 -> -	happyIn75-		 (happy_var_1-	)}--happyReduce_177 = happyMonadReduce 3# 65# 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 { (Loc happy_var_1 KW_Type) -> -	case happyOut215 happy_x_2 of { happy_var_2 -> -	case happyOut152 happy_x_3 of { happy_var_3 -> -	( checkExpr happy_var_3 >>= \e -> return (TypeAnn   (nIS happy_var_1 <++> ann e <** [happy_var_1]) happy_var_2 e))}}}-	) (\r -> happyReturn (happyIn76 r))--happyReduce_178 = happyMonadReduce 2# 65# happyReduction_178-happyReduction_178 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Module) -> -	case happyOut152 happy_x_2 of { happy_var_2 -> -	( checkExpr happy_var_2 >>= \e -> return (ModuleAnn (nIS happy_var_1 <++> ann e <** [happy_var_1])    e))}}-	) (\r -> happyReturn (happyIn76 r))--happyReduce_179 = happyMonadReduce 2# 65# happyReduction_179-happyReduction_179 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut75 happy_x_1 of { happy_var_1 -> -	case happyOut152 happy_x_2 of { happy_var_2 -> -	( checkExpr happy_var_2 >>= \e -> return (Ann (happy_var_1 <> e) happy_var_1 e))}}-	) (\r -> happyReturn (happyIn76 r))--happyReduce_180 = happyMonadReduce 1# 66# happyReduction_180-happyReduction_180 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut78 happy_x_1 of { happy_var_1 -> -	( checkType happy_var_1)}-	) (\r -> happyReturn (happyIn77 r))--happyReduce_181 = happySpecReduce_1  67# happyReduction_181-happyReduction_181 happy_x_1-	 =  case happyOut82 happy_x_1 of { happy_var_1 -> -	happyIn78-		 (happy_var_1-	)}--happyReduce_182 = happySpecReduce_3  67# happyReduction_182-happyReduction_182 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut82 happy_x_1 of { happy_var_1 -> -	case happyOut87 happy_x_2 of { happy_var_2 -> -	case happyOut78 happy_x_3 of { happy_var_3 -> -	happyIn78-		 (TyInfix (happy_var_1 <> happy_var_3) happy_var_1 happy_var_2 happy_var_3-	)}}}--happyReduce_183 = happySpecReduce_3  67# happyReduction_183-happyReduction_183 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut82 happy_x_1 of { happy_var_1 -> -	case happyOut231 happy_x_2 of { happy_var_2 -> -	case happyOut78 happy_x_3 of { happy_var_3 -> -	happyIn78-		 (TyInfix (happy_var_1 <> happy_var_3) happy_var_1 happy_var_2 happy_var_3-	)}}}--happyReduce_184 = happySpecReduce_3  67# happyReduction_184-happyReduction_184 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut82 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 RightArrow) -> -	case happyOut89 happy_x_3 of { happy_var_3 -> -	happyIn78-		 (TyFun (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3-	)}}}--happyReduce_185 = happyMonadReduce 3# 67# happyReduction_185-happyReduction_185 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut82 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 Tilde) -> -	case happyOut82 happy_x_3 of { happy_var_3 -> -	( do { checkEnabled TypeFamilies ;-                                              let {l = happy_var_1 <> happy_var_3 <** [happy_var_2]};-                                              return $ TyPred l $ EqualP l happy_var_1 happy_var_3 })}}}-	) (\r -> happyReturn (happyIn78 r))--happyReduce_186 = happyMonadReduce 1# 68# happyReduction_186-happyReduction_186 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut80 happy_x_1 of { happy_var_1 -> -	( checkType happy_var_1)}-	) (\r -> happyReturn (happyIn79 r))--happyReduce_187 = happySpecReduce_3  69# happyReduction_187-happyReduction_187 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut198 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 DoubleColon) -> -	case happyOut78 happy_x_3 of { happy_var_3 -> -	happyIn80-		 (let l = (happy_var_1 <> happy_var_3 <** [happy_var_2]) in TyPred l $ IParam l happy_var_1 happy_var_3-	)}}}--happyReduce_188 = happySpecReduce_1  69# happyReduction_188-happyReduction_188 happy_x_1-	 =  case happyOut78 happy_x_1 of { happy_var_1 -> -	happyIn80-		 (happy_var_1-	)}--happyReduce_189 = happyMonadReduce 1# 70# happyReduction_189-happyReduction_189 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut82 happy_x_1 of { happy_var_1 -> -	( checkType happy_var_1)}-	) (\r -> happyReturn (happyIn81 r))--happyReduce_190 = happySpecReduce_2  71# happyReduction_190-happyReduction_190 happy_x_2-	happy_x_1-	 =  case happyOut82 happy_x_1 of { happy_var_1 -> -	case happyOut84 happy_x_2 of { happy_var_2 -> -	happyIn82-		 (TyApp (happy_var_1 <> happy_var_2) happy_var_1 happy_var_2-	)}}--happyReduce_191 = happySpecReduce_1  71# happyReduction_191-happyReduction_191 happy_x_1-	 =  case happyOut84 happy_x_1 of { happy_var_1 -> -	happyIn82-		 (happy_var_1-	)}--happyReduce_192 = happyMonadReduce 1# 72# happyReduction_192-happyReduction_192 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut84 happy_x_1 of { happy_var_1 -> -	( checkType happy_var_1)}-	) (\r -> happyReturn (happyIn83 r))--happyReduce_193 = happySpecReduce_1  73# happyReduction_193-happyReduction_193 happy_x_1-	 =  case happyOut85 happy_x_1 of { happy_var_1 -> -	happyIn84-		 (TyCon   (ann happy_var_1) happy_var_1-	)}--happyReduce_194 = happySpecReduce_1  73# happyReduction_194-happyReduction_194 happy_x_1-	 =  case happyOut229 happy_x_1 of { happy_var_1 -> -	happyIn84-		 (TyVar   (ann happy_var_1) happy_var_1-	)}--happyReduce_195 = happySpecReduce_3  73# happyReduction_195-happyReduction_195 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> -	case happyOut91 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> -	happyIn84-		 (TyTuple (happy_var_1 <^^> happy_var_3 <** (happy_var_1:reverse (happy_var_3:snd happy_var_2))) Boxed   (reverse (fst happy_var_2))-	)}}}--happyReduce_196 = happySpecReduce_3  73# happyReduction_196-happyReduction_196 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftHashParen) -> -	case happyOut92 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightHashParen) -> -	happyIn84-		 (TyTuple (happy_var_1 <^^> happy_var_3 <** (happy_var_1:reverse (happy_var_3:snd happy_var_2))) Unboxed (reverse (fst happy_var_2))-	)}}}--happyReduce_197 = happySpecReduce_3  73# happyReduction_197-happyReduction_197 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftSquare) -> -	case happyOut80 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightSquare) -> -	happyIn84-		 (TyList  (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3]) happy_var_2-	)}}}--happyReduce_198 = happySpecReduce_3  73# happyReduction_198-happyReduction_198 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> -	case happyOut89 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> -	happyIn84-		 (TyParen (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3]) happy_var_2-	)}}}--happyReduce_199 = happyReduce 5# 73# happyReduction_199-happyReduction_199 (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 { (Loc happy_var_1 LeftParen) -> -	case happyOut89 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 DoubleColon) -> -	case happyOut119 happy_x_4 of { happy_var_4 -> -	case happyOutTok happy_x_5 of { (Loc happy_var_5 RightParen) -> -	happyIn84-		 (TyKind  (happy_var_1 <^^> happy_var_5 <** [happy_var_1,happy_var_3,happy_var_5]) happy_var_2 happy_var_4-	) `HappyStk` happyRest}}}}}--happyReduce_200 = happySpecReduce_1  74# happyReduction_200-happyReduction_200 happy_x_1-	 =  case happyOut86 happy_x_1 of { happy_var_1 -> -	happyIn85-		 (happy_var_1-	)}--happyReduce_201 = happySpecReduce_2  74# happyReduction_201-happyReduction_201 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 RightParen) -> -	happyIn85-		 (unit_tycon_name              (happy_var_1 <^^> happy_var_2 <** [happy_var_1,happy_var_2])-	)}}--happyReduce_202 = happySpecReduce_3  74# happyReduction_202-happyReduction_202 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 RightArrow) -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> -	happyIn85-		 (fun_tycon_name               (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_2,happy_var_3])-	)}}}--happyReduce_203 = happySpecReduce_2  74# happyReduction_203-happyReduction_203 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftSquare) -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 RightSquare) -> -	happyIn85-		 (list_tycon_name              (happy_var_1 <^^> happy_var_2 <** [happy_var_1,happy_var_2])-	)}}--happyReduce_204 = happySpecReduce_3  74# happyReduction_204-happyReduction_204 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> -	case happyOut155 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> -	happyIn85-		 (tuple_tycon_name             (happy_var_1 <^^> happy_var_3 <** (happy_var_1:reverse happy_var_2 ++ [happy_var_3])) Boxed (length happy_var_2)-	)}}}--happyReduce_205 = happySpecReduce_2  74# happyReduction_205-happyReduction_205 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftHashParen) -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 RightHashParen) -> -	happyIn85-		 (unboxed_singleton_tycon_name (happy_var_1 <^^> happy_var_2 <** [happy_var_1,happy_var_2])-	)}}--happyReduce_206 = happySpecReduce_3  74# happyReduction_206-happyReduction_206 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftHashParen) -> -	case happyOut155 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightHashParen) -> -	happyIn85-		 (tuple_tycon_name             (happy_var_1 <^^> happy_var_3 <** (happy_var_1:reverse happy_var_2 ++ [happy_var_3])) Unboxed (length happy_var_2)-	)}}}--happyReduce_207 = happySpecReduce_1  75# happyReduction_207-happyReduction_207 happy_x_1-	 =  case happyOut214 happy_x_1 of { happy_var_1 -> -	happyIn86-		 (happy_var_1-	)}--happyReduce_208 = happySpecReduce_3  75# happyReduction_208-happyReduction_208 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> -	case happyOut209 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> -	happyIn86-		 (fmap (const (happy_var_1 <^^> happy_var_3 <** [happy_var_1, srcInfoSpan (ann happy_var_2), happy_var_3])) happy_var_2-	)}}}--happyReduce_209 = happySpecReduce_3  75# happyReduction_209-happyReduction_209 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> -	case happyOut218 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> -	happyIn86-		 (fmap (const (happy_var_1 <^^> happy_var_3 <** [happy_var_1, srcInfoSpan (ann happy_var_2), happy_var_3])) happy_var_2-	)}}}--happyReduce_210 = happySpecReduce_1  76# happyReduction_210-happyReduction_210 happy_x_1-	 =  case happyOut205 happy_x_1 of { happy_var_1 -> -	happyIn87-		 (happy_var_1-	)}--happyReduce_211 = happyMonadReduce 1# 77# happyReduction_211-happyReduction_211 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut89 happy_x_1 of { happy_var_1 -> -	( checkType happy_var_1)}-	) (\r -> happyReturn (happyIn88 r))--happyReduce_212 = happyReduce 4# 78# happyReduction_212-happyReduction_212 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Forall) -> -	case happyOut93 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 Dot) -> -	case happyOut89 happy_x_4 of { happy_var_4 -> -	happyIn89-		 (TyForall (nIS happy_var_1 <++> ann happy_var_4 <** [happy_var_1,happy_var_3]) (Just (reverse (fst happy_var_2))) Nothing happy_var_4-	) `HappyStk` happyRest}}}}--happyReduce_213 = happySpecReduce_2  78# happyReduction_213-happyReduction_213 happy_x_2-	happy_x_1-	 =  case happyOut90 happy_x_1 of { happy_var_1 -> -	case happyOut89 happy_x_2 of { happy_var_2 -> -	happyIn89-		 (TyForall (happy_var_1 <> happy_var_2) Nothing (Just happy_var_1) happy_var_2-	)}}--happyReduce_214 = happySpecReduce_1  78# happyReduction_214-happyReduction_214 happy_x_1-	 =  case happyOut80 happy_x_1 of { happy_var_1 -> -	happyIn89-		 (happy_var_1-	)}--happyReduce_215 = happyMonadReduce 2# 79# happyReduction_215-happyReduction_215 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut82 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 DoubleArrow) -> -	( checkPContext $ (amap (\l -> l <++> nIS happy_var_2 <** (srcInfoPoints l ++ [happy_var_2]))) happy_var_1)}}-	) (\r -> happyReturn (happyIn90 r))--happyReduce_216 = happyMonadReduce 4# 79# happyReduction_216-happyReduction_216 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut82 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 Tilde) -> -	case happyOut82 happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { (Loc happy_var_4 DoubleArrow) -> -	( do { checkEnabled TypeFamilies;-                                              let {l = happy_var_1 <> happy_var_3 <** [happy_var_2,happy_var_4]};-                                              checkPContext (TyPred l $ EqualP l happy_var_1 happy_var_3) })}}}}-	) (\r -> happyReturn (happyIn90 r))--happyReduce_217 = happySpecReduce_3  80# happyReduction_217-happyReduction_217 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut92 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> -	case happyOut89 happy_x_3 of { happy_var_3 -> -	happyIn91-		 ((happy_var_3 : fst happy_var_1, happy_var_2 : snd happy_var_1)-	)}}}--happyReduce_218 = happySpecReduce_1  81# happyReduction_218-happyReduction_218 happy_x_1-	 =  case happyOut89 happy_x_1 of { happy_var_1 -> -	happyIn92-		 (([happy_var_1],[])-	)}--happyReduce_219 = happySpecReduce_3  81# happyReduction_219-happyReduction_219 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut92 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> -	case happyOut89 happy_x_3 of { happy_var_3 -> -	happyIn92-		 ((happy_var_3 : fst happy_var_1, happy_var_2 : snd happy_var_1)-	)}}}--happyReduce_220 = happySpecReduce_2  82# happyReduction_220-happyReduction_220 happy_x_2-	happy_x_1-	 =  case happyOut93 happy_x_1 of { happy_var_1 -> -	case happyOut94 happy_x_2 of { happy_var_2 -> -	happyIn93-		 ((happy_var_2 : fst happy_var_1, Just (snd happy_var_1 <?+> ann happy_var_2))-	)}}--happyReduce_221 = happySpecReduce_0  82# happyReduction_221-happyReduction_221  =  happyIn93-		 (([],Nothing)-	)--happyReduce_222 = happySpecReduce_1  83# happyReduction_222-happyReduction_222 happy_x_1-	 =  case happyOut229 happy_x_1 of { happy_var_1 -> -	happyIn94-		 (UnkindedVar (ann happy_var_1) happy_var_1-	)}--happyReduce_223 = happyReduce 5# 83# happyReduction_223-happyReduction_223 (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 { (Loc happy_var_1 LeftParen) -> -	case happyOut229 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 DoubleColon) -> -	case happyOut119 happy_x_4 of { happy_var_4 -> -	case happyOutTok happy_x_5 of { (Loc happy_var_5 RightParen) -> -	happyIn94-		 (KindedVar (happy_var_1 <^^> happy_var_5 <** [happy_var_1,happy_var_3,happy_var_5]) happy_var_2 happy_var_4-	) `HappyStk` happyRest}}}}}--happyReduce_224 = happySpecReduce_2  84# happyReduction_224-happyReduction_224 happy_x_2-	happy_x_1-	 =  case happyOut95 happy_x_1 of { happy_var_1 -> -	case happyOut229 happy_x_2 of { happy_var_2 -> -	happyIn95-		 ((happy_var_2 : fst happy_var_1, Just (snd happy_var_1 <?+> ann happy_var_2))-	)}}--happyReduce_225 = happySpecReduce_0  84# happyReduction_225-happyReduction_225  =  happyIn95-		 (([], Nothing)-	)--happyReduce_226 = happySpecReduce_2  85# happyReduction_226-happyReduction_226 happy_x_2-	happy_x_1-	 =  case happyOut95 happy_x_1 of { happy_var_1 -> -	case happyOut229 happy_x_2 of { happy_var_2 -> -	happyIn96-		 ((happy_var_2 : fst happy_var_1, snd happy_var_1 <?+> ann happy_var_2)-	)}}--happyReduce_227 = happySpecReduce_0  86# happyReduction_227-happyReduction_227  =  happyIn97-		 (([],[], Nothing)-	)--happyReduce_228 = happyMonadReduce 2# 86# happyReduction_228-happyReduction_228 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 Bar) -> -	case happyOut98 happy_x_2 of { happy_var_2 -> -	( do { checkEnabled FunctionalDependencies ;-                                              let {(fds,ss,l) = happy_var_2} ;-                                              return (reverse fds, happy_var_1 : reverse ss, Just (nIS happy_var_1 <++> l)) })}}-	) (\r -> happyReturn (happyIn97 r))--happyReduce_229 = happySpecReduce_3  87# happyReduction_229-happyReduction_229 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut98 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> -	case happyOut99 happy_x_3 of { happy_var_3 -> -	happyIn98-		 (let (fds,ss,l) = happy_var_1 in (happy_var_3 : fds, happy_var_2 : ss, l <++> ann happy_var_3)-	)}}}--happyReduce_230 = happySpecReduce_1  87# happyReduction_230-happyReduction_230 happy_x_1-	 =  case happyOut99 happy_x_1 of { happy_var_1 -> -	happyIn98-		 (([happy_var_1],[],ann happy_var_1)-	)}--happyReduce_231 = happySpecReduce_3  88# happyReduction_231-happyReduction_231 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut95 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 RightArrow) -> -	case happyOut96 happy_x_3 of { happy_var_3 -> -	happyIn99-		 (FunDep (snd happy_var_1 <?+> nIS happy_var_2 <++> snd happy_var_3 <** [happy_var_2]) (reverse (fst happy_var_1)) (reverse (fst happy_var_3))-	)}}}--happyReduce_232 = happyMonadReduce 4# 89# happyReduction_232-happyReduction_232 (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 { (Loc happy_var_1 KW_Where) -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftCurly) -> -	case happyOut101 happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { (Loc happy_var_4 RightCurly) -> -	( return (fst happy_var_3, happy_var_1 : happy_var_2 : snd happy_var_3 ++ [happy_var_4], Just $ happy_var_1 <^^> happy_var_4))}}}}-	) (\r -> happyReturn (happyIn100 r))--happyReduce_233 = happyMonadReduce 4# 89# happyReduction_233-happyReduction_233 (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 { (Loc happy_var_1 KW_Where) -> -	case happyOut224 happy_x_2 of { happy_var_2 -> -	case happyOut101 happy_x_3 of { happy_var_3 -> -	case happyOut225 happy_x_4 of { happy_var_4 -> -	( return (fst happy_var_3, happy_var_1 : happy_var_2 : snd happy_var_3 ++ [happy_var_4], Just $ happy_var_1 <^^> happy_var_4))}}}}-	) (\r -> happyReturn (happyIn100 r))--happyReduce_234 = happyMonadReduce 0# 89# happyReduction_234-happyReduction_234 (happyRest) tk-	 = happyThen (( checkEnabled EmptyDataDecls >> return ([],[],Nothing))-	) (\r -> happyReturn (happyIn100 r))--happyReduce_235 = happySpecReduce_3  90# happyReduction_235-happyReduction_235 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut25 happy_x_1 of { happy_var_1 -> -	case happyOut102 happy_x_2 of { happy_var_2 -> -	case happyOut25 happy_x_3 of { happy_var_3 -> -	happyIn101-		 ((fst happy_var_2, reverse happy_var_1 ++ snd happy_var_2 ++ reverse happy_var_3)-	)}}}--happyReduce_236 = happySpecReduce_3  91# happyReduction_236-happyReduction_236 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut102 happy_x_1 of { happy_var_1 -> -	case happyOut24 happy_x_2 of { happy_var_2 -> -	case happyOut103 happy_x_3 of { happy_var_3 -> -	happyIn102-		 ((happy_var_3 : fst happy_var_1, snd happy_var_1 ++ reverse happy_var_2)-	)}}}--happyReduce_237 = happySpecReduce_1  91# happyReduction_237-happyReduction_237 happy_x_1-	 =  case happyOut103 happy_x_1 of { happy_var_1 -> -	happyIn102-		 (([happy_var_1],[])-	)}--happyReduce_238 = happyMonadReduce 3# 92# happyReduction_238-happyReduction_238 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut200 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 DoubleColon) -> -	case happyOut88 happy_x_3 of { happy_var_3 -> -	( do { c <- checkUnQual happy_var_1;-                                               return $ GadtDecl (happy_var_1 <> happy_var_3 <** [happy_var_2]) c happy_var_3 })}}}-	) (\r -> happyReturn (happyIn103 r))--happyReduce_239 = happySpecReduce_2  93# happyReduction_239-happyReduction_239 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Equals) -> -	case happyOut105 happy_x_2 of { happy_var_2 -> -	happyIn104-		 (let (ds,ss,l) = happy_var_2 in (ds, happy_var_1 : reverse ss, Just $ nIS happy_var_1 <++> l)-	)}}--happyReduce_240 = happySpecReduce_3  94# happyReduction_240-happyReduction_240 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut105 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 Bar) -> -	case happyOut106 happy_x_3 of { happy_var_3 -> -	happyIn105-		 (let (ds,ss,l) = happy_var_1 in (happy_var_3 : ds, happy_var_2 : ss, l <++> ann happy_var_3)-	)}}}--happyReduce_241 = happySpecReduce_1  94# happyReduction_241-happyReduction_241 happy_x_1-	 =  case happyOut106 happy_x_1 of { happy_var_1 -> -	happyIn105-		 (([happy_var_1],[],ann happy_var_1)-	)}--happyReduce_242 = happyMonadReduce 3# 95# happyReduction_242-happyReduction_242 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut107 happy_x_1 of { happy_var_1 -> -	case happyOut90 happy_x_2 of { happy_var_2 -> -	case happyOut108 happy_x_3 of { happy_var_3 -> -	( do { checkEnabled ExistentialQuantification ;-                                               ctxt <- checkContext (Just happy_var_2) ;-                                               let {(mtvs,ss,ml) = happy_var_1} ;-                                               return $ QualConDecl (ml <?+> ann happy_var_3 <** ss) mtvs ctxt happy_var_3 })}}}-	) (\r -> happyReturn (happyIn106 r))--happyReduce_243 = happySpecReduce_2  95# happyReduction_243-happyReduction_243 happy_x_2-	happy_x_1-	 =  case happyOut107 happy_x_1 of { happy_var_1 -> -	case happyOut108 happy_x_2 of { happy_var_2 -> -	happyIn106-		 (let (mtvs, ss, ml) = happy_var_1 in QualConDecl (ml <?+> ann happy_var_2 <** ss) mtvs Nothing happy_var_2-	)}}--happyReduce_244 = happyMonadReduce 3# 96# happyReduction_244-happyReduction_244 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Forall) -> -	case happyOut93 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 Dot) -> -	( checkEnabled ExistentialQuantification >> return (Just (fst happy_var_2), [happy_var_1,happy_var_3], Just $ happy_var_1 <^^> happy_var_3))}}}-	) (\r -> happyReturn (happyIn107 r))--happyReduce_245 = happySpecReduce_0  96# happyReduction_245-happyReduction_245  =  happyIn107-		 ((Nothing, [], Nothing)-	)--happyReduce_246 = happySpecReduce_1  97# happyReduction_246-happyReduction_246 happy_x_1-	 =  case happyOut109 happy_x_1 of { happy_var_1 -> -	happyIn108-		 (let (n,ts,l) = happy_var_1 in ConDecl l n ts-	)}--happyReduce_247 = happySpecReduce_3  97# happyReduction_247-happyReduction_247 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut112 happy_x_1 of { happy_var_1 -> -	case happyOut204 happy_x_2 of { happy_var_2 -> -	case happyOut112 happy_x_3 of { happy_var_3 -> -	happyIn108-		 (InfixConDecl (happy_var_1 <> happy_var_3) happy_var_1 happy_var_2 happy_var_3-	)}}}--happyReduce_248 = happyMonadReduce 3# 97# happyReduction_248-happyReduction_248 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut200 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftCurly) -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightCurly) -> -	( do { c <- checkUnQual happy_var_1; return $ RecDecl (ann happy_var_1 <++> nIS happy_var_3 <** [happy_var_2,happy_var_3]) c [] })}}}-	) (\r -> happyReturn (happyIn108 r))--happyReduce_249 = happyMonadReduce 4# 97# happyReduction_249-happyReduction_249 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut200 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftCurly) -> -	case happyOut113 happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { (Loc happy_var_4 RightCurly) -> -	( do { c <- checkUnQual happy_var_1;-                                              return $ RecDecl (ann happy_var_1 <++> nIS happy_var_4 <** (happy_var_2:reverse (snd happy_var_3) ++ [happy_var_4])) c (reverse (fst happy_var_3)) })}}}}-	) (\r -> happyReturn (happyIn108 r))--happyReduce_250 = happyMonadReduce 1# 98# happyReduction_250-happyReduction_250 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut82 happy_x_1 of { happy_var_1 -> -	( do { (c,ts) <- splitTyConApp happy_var_1;-                                              return (c,map (\t -> UnBangedTy (ann t) t) ts,ann happy_var_1) })}-	) (\r -> happyReturn (happyIn109 r))--happyReduce_251 = happySpecReduce_1  98# happyReduction_251-happyReduction_251 happy_x_1-	 =  case happyOut110 happy_x_1 of { happy_var_1 -> -	happyIn109-		 (happy_var_1-	)}--happyReduce_252 = happyMonadReduce 3# 99# happyReduction_252-happyReduction_252 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut82 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 Exclamation) -> -	case happyOut83 happy_x_3 of { happy_var_3 -> -	( do { (c,ts) <- splitTyConApp happy_var_1;-                                                          return (c,map (\t -> UnBangedTy (ann t) t) ts++-                                                                  [BangedTy (nIS happy_var_2 <++> ann happy_var_3 <** [happy_var_2]) happy_var_3], happy_var_1 <> happy_var_3) })}}}-	) (\r -> happyReturn (happyIn110 r))--happyReduce_253 = happyMonadReduce 5# 99# happyReduction_253-happyReduction_253 (happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut82 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 UNPACK) -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 PragmaEnd) -> -	case happyOutTok happy_x_4 of { (Loc happy_var_4 Exclamation) -> -	case happyOut83 happy_x_5 of { happy_var_5 -> -	( do { (c,ts) <- splitTyConApp happy_var_1;-                                                          return (c,map (\t -> UnBangedTy (ann t) t) ts++-                                                                  [UnpackedTy (nIS happy_var_2 <++> ann happy_var_5 <** [happy_var_2,happy_var_3,happy_var_4]) happy_var_5], happy_var_1 <> happy_var_5) })}}}}}-	) (\r -> happyReturn (happyIn110 r))--happyReduce_254 = happySpecReduce_2  99# happyReduction_254-happyReduction_254 happy_x_2-	happy_x_1-	 =  case happyOut110 happy_x_1 of { happy_var_1 -> -	case happyOut111 happy_x_2 of { happy_var_2 -> -	happyIn110-		 (let (n,ts,l) = happy_var_1 in (n, ts ++ [happy_var_2],l <++> ann happy_var_2)-	)}}--happyReduce_255 = happySpecReduce_1  100# happyReduction_255-happyReduction_255 happy_x_1-	 =  case happyOut83 happy_x_1 of { happy_var_1 -> -	happyIn111-		 (UnBangedTy (ann happy_var_1) happy_var_1-	)}--happyReduce_256 = happySpecReduce_2  100# happyReduction_256-happyReduction_256 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Exclamation) -> -	case happyOut83 happy_x_2 of { happy_var_2 -> -	happyIn111-		 (BangedTy   (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2-	)}}--happyReduce_257 = happyReduce 4# 100# happyReduction_257-happyReduction_257 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 UNPACK) -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 PragmaEnd) -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 Exclamation) -> -	case happyOut83 happy_x_4 of { happy_var_4 -> -	happyIn111-		 (UnpackedTy (nIS happy_var_1 <++> ann happy_var_4 <** [happy_var_1,happy_var_2,happy_var_3]) happy_var_4-	) `HappyStk` happyRest}}}}--happyReduce_258 = happySpecReduce_1  101# happyReduction_258-happyReduction_258 happy_x_1-	 =  case happyOut81 happy_x_1 of { happy_var_1 -> -	happyIn112-		 (UnBangedTy (ann happy_var_1) happy_var_1-	)}--happyReduce_259 = happySpecReduce_2  101# happyReduction_259-happyReduction_259 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Exclamation) -> -	case happyOut83 happy_x_2 of { happy_var_2 -> -	happyIn112-		 (BangedTy   (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2-	)}}--happyReduce_260 = happyReduce 4# 101# happyReduction_260-happyReduction_260 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 UNPACK) -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 PragmaEnd) -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 Exclamation) -> -	case happyOut83 happy_x_4 of { happy_var_4 -> -	happyIn112-		 (UnpackedTy (nIS happy_var_1 <++> ann happy_var_4 <** [happy_var_1,happy_var_2,happy_var_3]) happy_var_4-	) `HappyStk` happyRest}}}}--happyReduce_261 = happySpecReduce_3  102# happyReduction_261-happyReduction_261 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut113 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> -	case happyOut114 happy_x_3 of { happy_var_3 -> -	happyIn113-		 ((happy_var_3 : fst happy_var_1, happy_var_2 : snd happy_var_1)-	)}}}--happyReduce_262 = happySpecReduce_1  102# happyReduction_262-happyReduction_262 happy_x_1-	 =  case happyOut114 happy_x_1 of { happy_var_1 -> -	happyIn113-		 (([happy_var_1],[])-	)}--happyReduce_263 = happySpecReduce_3  103# happyReduction_263-happyReduction_263 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut62 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 DoubleColon) -> -	case happyOut115 happy_x_3 of { happy_var_3 -> -	happyIn114-		 (let (ns,ss,l) = happy_var_1 in FieldDecl (l <++> ann happy_var_3 <** (reverse ss ++ [happy_var_2])) (reverse ns) happy_var_3-	)}}}--happyReduce_264 = happySpecReduce_1  104# happyReduction_264-happyReduction_264 happy_x_1-	 =  case happyOut88 happy_x_1 of { happy_var_1 -> -	happyIn115-		 (UnBangedTy (ann happy_var_1) happy_var_1-	)}--happyReduce_265 = happySpecReduce_2  104# happyReduction_265-happyReduction_265 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Exclamation) -> -	case happyOut83 happy_x_2 of { happy_var_2 -> -	happyIn115-		 (BangedTy   (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2-	)}}--happyReduce_266 = happyReduce 4# 104# happyReduction_266-happyReduction_266 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 UNPACK) -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 PragmaEnd) -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 Exclamation) -> -	case happyOut83 happy_x_4 of { happy_var_4 -> -	happyIn115-		 (UnpackedTy (nIS happy_var_1 <++> ann happy_var_4 <** [happy_var_1,happy_var_2,happy_var_3]) happy_var_4-	) `HappyStk` happyRest}}}}--happyReduce_267 = happySpecReduce_0  105# happyReduction_267-happyReduction_267  =  happyIn116-		 (Nothing-	)--happyReduce_268 = happySpecReduce_2  105# happyReduction_268-happyReduction_268 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Deriving) -> -	case happyOut118 happy_x_2 of { happy_var_2 -> -	happyIn116-		 (let l = nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1] in Just $ Deriving l [IHead (ann happy_var_2) happy_var_2 []]-	)}}--happyReduce_269 = happySpecReduce_3  105# happyReduction_269-happyReduction_269 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Deriving) -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftParen) -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> -	happyIn116-		 (Just $ Deriving (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_2,happy_var_3]) []-	)}}}--happyReduce_270 = happyReduce 4# 105# happyReduction_270-happyReduction_270 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Deriving) -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftParen) -> -	case happyOut117 happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { (Loc happy_var_4 RightParen) -> -	happyIn116-		 (Just $ Deriving (happy_var_1 <^^> happy_var_4 <** happy_var_1:happy_var_2: reverse (snd happy_var_3) ++ [happy_var_4]) (reverse (fst happy_var_3))-	) `HappyStk` happyRest}}}}--happyReduce_271 = happyMonadReduce 1# 106# happyReduction_271-happyReduction_271 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut92 happy_x_1 of { happy_var_1 -> -	( checkDeriving (fst happy_var_1) >>= \ds -> return (ds, snd happy_var_1))}-	) (\r -> happyReturn (happyIn117 r))--happyReduce_272 = happySpecReduce_1  107# happyReduction_272-happyReduction_272 happy_x_1-	 =  case happyOut214 happy_x_1 of { happy_var_1 -> -	happyIn118-		 (happy_var_1-	)}--happyReduce_273 = happyMonadReduce 1# 108# happyReduction_273-happyReduction_273 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut120 happy_x_1 of { happy_var_1 -> -	( checkEnabled KindSignatures >> return happy_var_1)}-	) (\r -> happyReturn (happyIn119 r))--happyReduce_274 = happySpecReduce_1  109# happyReduction_274-happyReduction_274 happy_x_1-	 =  case happyOut121 happy_x_1 of { happy_var_1 -> -	happyIn120-		 (happy_var_1-	)}--happyReduce_275 = happySpecReduce_3  109# happyReduction_275-happyReduction_275 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut121 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 RightArrow) -> -	case happyOut120 happy_x_3 of { happy_var_3 -> -	happyIn120-		 (KindFn (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3-	)}}}--happyReduce_276 = happySpecReduce_1  110# happyReduction_276-happyReduction_276 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Star) -> -	happyIn121-		 (KindStar  (nIS happy_var_1)-	)}--happyReduce_277 = happySpecReduce_1  110# happyReduction_277-happyReduction_277 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Exclamation) -> -	happyIn121-		 (KindBang  (nIS happy_var_1)-	)}--happyReduce_278 = happySpecReduce_3  110# happyReduction_278-happyReduction_278 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> -	case happyOut120 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> -	happyIn121-		 (KindParen (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3]) happy_var_2-	)}}}--happyReduce_279 = happySpecReduce_0  111# happyReduction_279-happyReduction_279  =  happyIn122-		 ((Nothing,[])-	)--happyReduce_280 = happySpecReduce_2  111# happyReduction_280-happyReduction_280 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 DoubleColon) -> -	case happyOut119 happy_x_2 of { happy_var_2 -> -	happyIn122-		 ((Just happy_var_2,[happy_var_1])-	)}}--happyReduce_281 = happyMonadReduce 4# 112# happyReduction_281-happyReduction_281 (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 { (Loc happy_var_1 KW_Where) -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftCurly) -> -	case happyOut124 happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { (Loc happy_var_4 RightCurly) -> -	( checkClassBody (fst happy_var_3) >>= \vs -> return (Just vs, happy_var_1:happy_var_2: snd happy_var_3 ++ [happy_var_4], Just (happy_var_1 <^^> happy_var_4)))}}}}-	) (\r -> happyReturn (happyIn123 r))--happyReduce_282 = happyMonadReduce 4# 112# happyReduction_282-happyReduction_282 (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 { (Loc happy_var_1 KW_Where) -> -	case happyOut224 happy_x_2 of { happy_var_2 -> -	case happyOut124 happy_x_3 of { happy_var_3 -> -	case happyOut225 happy_x_4 of { happy_var_4 -> -	( checkClassBody (fst happy_var_3) >>= \vs -> return (Just vs, happy_var_1:happy_var_2: snd happy_var_3 ++ [happy_var_4], Just (happy_var_1 <^^> happy_var_4)))}}}}-	) (\r -> happyReturn (happyIn123 r))--happyReduce_283 = happySpecReduce_0  112# happyReduction_283-happyReduction_283  =  happyIn123-		 ((Nothing,[],Nothing)-	)--happyReduce_284 = happyMonadReduce 3# 113# happyReduction_284-happyReduction_284 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut25 happy_x_1 of { happy_var_1 -> -	case happyOut125 happy_x_2 of { happy_var_2 -> -	case happyOut25 happy_x_3 of { happy_var_3 -> -	( checkRevClsDecls (fst happy_var_2) >>= \cs -> return (cs, reverse happy_var_1 ++ snd happy_var_2 ++ reverse happy_var_3))}}}-	) (\r -> happyReturn (happyIn124 r))--happyReduce_285 = happySpecReduce_1  113# happyReduction_285-happyReduction_285 happy_x_1-	 =  case happyOut25 happy_x_1 of { happy_var_1 -> -	happyIn124-		 (([],reverse happy_var_1)-	)}--happyReduce_286 = happySpecReduce_3  114# happyReduction_286-happyReduction_286 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut125 happy_x_1 of { happy_var_1 -> -	case happyOut24 happy_x_2 of { happy_var_2 -> -	case happyOut126 happy_x_3 of { happy_var_3 -> -	happyIn125-		 ((happy_var_3 : fst happy_var_1, snd happy_var_1 ++ reverse happy_var_2)-	)}}}--happyReduce_287 = happySpecReduce_1  114# happyReduction_287-happyReduction_287 happy_x_1-	 =  case happyOut126 happy_x_1 of { happy_var_1 -> -	happyIn125-		 (([happy_var_1],[])-	)}--happyReduce_288 = happySpecReduce_1  115# happyReduction_288-happyReduction_288 happy_x_1-	 =  case happyOut55 happy_x_1 of { happy_var_1 -> -	happyIn126-		 (ClsDecl (ann happy_var_1) happy_var_1-	)}--happyReduce_289 = happyMonadReduce 1# 115# happyReduction_289-happyReduction_289 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut127 happy_x_1 of { happy_var_1 -> -	( checkEnabled TypeFamilies >> return happy_var_1)}-	) (\r -> happyReturn (happyIn126 r))--happyReduce_290 = happyMonadReduce 3# 116# happyReduction_290-happyReduction_290 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Type) -> -	case happyOut80 happy_x_2 of { happy_var_2 -> -	case happyOut122 happy_x_3 of { happy_var_3 -> -	( do { dh <- checkSimpleType happy_var_2;-                    return (ClsTyFam  (nIS happy_var_1 <++> ann happy_var_2 <+?> (fmap ann) (fst happy_var_3) <** happy_var_1:snd happy_var_3) dh (fst happy_var_3)) })}}}-	) (\r -> happyReturn (happyIn127 r))--happyReduce_291 = happyReduce 4# 116# happyReduction_291-happyReduction_291 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Type) -> -	case happyOut77 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 Equals) -> -	case happyOut88 happy_x_4 of { happy_var_4 -> -	happyIn127-		 (ClsTyDef (nIS happy_var_1 <++> ann happy_var_4 <** [happy_var_1,happy_var_3]) happy_var_2 happy_var_4-	) `HappyStk` happyRest}}}}--happyReduce_292 = happyMonadReduce 3# 116# happyReduction_292-happyReduction_292 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Data) -> -	case happyOut89 happy_x_2 of { happy_var_2 -> -	case happyOut122 happy_x_3 of { happy_var_3 -> -	( do { (cs,dh) <- checkDataHeader happy_var_2;-                    return (ClsDataFam (nIS happy_var_1 <++> ann happy_var_2 <+?> (fmap ann) (fst happy_var_3) <** happy_var_1:snd happy_var_3) cs dh (fst happy_var_3)) })}}}-	) (\r -> happyReturn (happyIn127 r))--happyReduce_293 = happyMonadReduce 4# 117# happyReduction_293-happyReduction_293 (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 { (Loc happy_var_1 KW_Where) -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftCurly) -> -	case happyOut129 happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { (Loc happy_var_4 RightCurly) -> -	( checkInstBody (fst happy_var_3) >>= \vs -> return (Just vs, happy_var_1:happy_var_2: snd happy_var_3 ++ [happy_var_4], Just (happy_var_1 <^^> happy_var_4)))}}}}-	) (\r -> happyReturn (happyIn128 r))--happyReduce_294 = happyMonadReduce 4# 117# happyReduction_294-happyReduction_294 (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 { (Loc happy_var_1 KW_Where) -> -	case happyOut224 happy_x_2 of { happy_var_2 -> -	case happyOut129 happy_x_3 of { happy_var_3 -> -	case happyOut225 happy_x_4 of { happy_var_4 -> -	( checkInstBody (fst happy_var_3) >>= \vs -> return (Just vs, happy_var_1:happy_var_2: snd happy_var_3 ++ [happy_var_4], Just (happy_var_1 <^^> happy_var_4)))}}}}-	) (\r -> happyReturn (happyIn128 r))--happyReduce_295 = happySpecReduce_0  117# happyReduction_295-happyReduction_295  =  happyIn128-		 ((Nothing, [], Nothing)-	)--happyReduce_296 = happyMonadReduce 3# 118# happyReduction_296-happyReduction_296 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut25 happy_x_1 of { happy_var_1 -> -	case happyOut130 happy_x_2 of { happy_var_2 -> -	case happyOut25 happy_x_3 of { happy_var_3 -> -	( checkRevInstDecls (fst happy_var_2) >>= \is -> return (is, reverse happy_var_1 ++ snd happy_var_2 ++ reverse happy_var_3))}}}-	) (\r -> happyReturn (happyIn129 r))--happyReduce_297 = happySpecReduce_1  118# happyReduction_297-happyReduction_297 happy_x_1-	 =  case happyOut25 happy_x_1 of { happy_var_1 -> -	happyIn129-		 (([],reverse happy_var_1)-	)}--happyReduce_298 = happySpecReduce_3  119# happyReduction_298-happyReduction_298 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut130 happy_x_1 of { happy_var_1 -> -	case happyOut24 happy_x_2 of { happy_var_2 -> -	case happyOut131 happy_x_3 of { happy_var_3 -> -	happyIn130-		 ((happy_var_3 : fst happy_var_1, snd happy_var_1 ++ reverse happy_var_2)-	)}}}--happyReduce_299 = happySpecReduce_1  119# happyReduction_299-happyReduction_299 happy_x_1-	 =  case happyOut131 happy_x_1 of { happy_var_1 -> -	happyIn130-		 (([happy_var_1],[])-	)}--happyReduce_300 = happySpecReduce_1  120# happyReduction_300-happyReduction_300 happy_x_1-	 =  case happyOut133 happy_x_1 of { happy_var_1 -> -	happyIn131-		 (InsDecl (ann happy_var_1) happy_var_1-	)}--happyReduce_301 = happyMonadReduce 1# 120# happyReduction_301-happyReduction_301 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut132 happy_x_1 of { happy_var_1 -> -	( checkEnabled TypeFamilies >> return happy_var_1)}-	) (\r -> happyReturn (happyIn131 r))--happyReduce_302 = happySpecReduce_1  120# happyReduction_302-happyReduction_302 happy_x_1-	 =  case happyOut58 happy_x_1 of { happy_var_1 -> -	happyIn131-		 (InsDecl (ann happy_var_1) happy_var_1-	)}--happyReduce_303 = happyMonadReduce 4# 121# happyReduction_303-happyReduction_303 (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 { (Loc happy_var_1 KW_Type) -> -	case happyOut77 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 Equals) -> -	case happyOut88 happy_x_4 of { happy_var_4 -> -	( do { -- no checkSimpleType happy_var_4 since dtype may contain type patterns-                       return (InsType (nIS happy_var_1 <++> ann happy_var_4 <** [happy_var_1,happy_var_3]) happy_var_2 happy_var_4) })}}}}-	) (\r -> happyReturn (happyIn132 r))--happyReduce_304 = happyMonadReduce 4# 121# happyReduction_304-happyReduction_304 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut51 happy_x_1 of { happy_var_1 -> -	case happyOut88 happy_x_2 of { happy_var_2 -> -	case happyOut104 happy_x_3 of { happy_var_3 -> -	case happyOut116 happy_x_4 of { happy_var_4 -> -	( do { -- (cs,c,t) <- checkDataHeader happy_var_4;-                       let {(ds,ss,minf) = happy_var_3};-                       checkDataOrNew happy_var_1 ds;-                       return (InsData (happy_var_1 <> happy_var_2 <+?> minf <+?> fmap ann happy_var_4 <** ss ) happy_var_1 happy_var_2 (reverse ds) happy_var_4) })}}}}-	) (\r -> happyReturn (happyIn132 r))--happyReduce_305 = happyMonadReduce 5# 121# 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 happyOut51 happy_x_1 of { happy_var_1 -> -	case happyOut88 happy_x_2 of { happy_var_2 -> -	case happyOut122 happy_x_3 of { happy_var_3 -> -	case happyOut100 happy_x_4 of { happy_var_4 -> -	case happyOut116 happy_x_5 of { happy_var_5 -> -	( do { -- (cs,c,t) <- checkDataHeader happy_var_4;-                       let { (gs,ss,minf) = happy_var_4 } ;-                       checkDataOrNewG happy_var_1 gs;-                       return $ InsGData (ann happy_var_1 <+?> minf <+?> fmap ann happy_var_5 <** (snd happy_var_3 ++ ss)) happy_var_1 happy_var_2 (fst happy_var_3) (reverse gs) happy_var_5 })}}}}}-	) (\r -> happyReturn (happyIn132 r))--happyReduce_306 = happyMonadReduce 4# 122# happyReduction_306-happyReduction_306 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut143 happy_x_1 of { happy_var_1 -> -	case happyOut135 happy_x_2 of { happy_var_2 -> -	case happyOut136 happy_x_3 of { happy_var_3 -> -	case happyOut134 happy_x_4 of { happy_var_4 -> -	( checkValDef ((happy_var_1 <> happy_var_3 <+?> (fmap ann) (fst happy_var_4)) <** (snd happy_var_2 ++ snd happy_var_4)) happy_var_1 (fst happy_var_2) happy_var_3 (fst happy_var_4))}}}}-	) (\r -> happyReturn (happyIn133 r))--happyReduce_307 = happyMonadReduce 4# 122# happyReduction_307-happyReduction_307 (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 { (Loc happy_var_1 Exclamation) -> -	case happyOut152 happy_x_2 of { happy_var_2 -> -	case happyOut136 happy_x_3 of { happy_var_3 -> -	case happyOut134 happy_x_4 of { happy_var_4 -> -	( do { checkEnabled BangPatterns ;-                                              let { l = nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1] };-                                              p <- checkPattern (BangPat l happy_var_2);-                                              return $ PatBind (p <> happy_var_3 <+?> (fmap ann) (fst happy_var_4) <** snd happy_var_4)-                                                          p Nothing happy_var_3 (fst happy_var_4) })}}}}-	) (\r -> happyReturn (happyIn133 r))--happyReduce_308 = happySpecReduce_2  123# happyReduction_308-happyReduction_308 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Where) -> -	case happyOut61 happy_x_2 of { happy_var_2 -> -	happyIn134-		 ((Just happy_var_2, [happy_var_1])-	)}}--happyReduce_309 = happySpecReduce_0  123# happyReduction_309-happyReduction_309  =  happyIn134-		 ((Nothing, [])-	)--happyReduce_310 = happyMonadReduce 2# 124# happyReduction_310-happyReduction_310 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 DoubleColon) -> -	case happyOut88 happy_x_2 of { happy_var_2 -> -	( checkEnabled ScopedTypeVariables >> return (Just happy_var_2, [happy_var_1]))}}-	) (\r -> happyReturn (happyIn135 r))--happyReduce_311 = happySpecReduce_0  124# happyReduction_311-happyReduction_311  =  happyIn135-		 ((Nothing,[])-	)--happyReduce_312 = happySpecReduce_2  125# happyReduction_312-happyReduction_312 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Equals) -> -	case happyOut139 happy_x_2 of { happy_var_2 -> -	happyIn136-		 (UnGuardedRhs (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2-	)}}--happyReduce_313 = happySpecReduce_1  125# happyReduction_313-happyReduction_313 happy_x_1-	 =  case happyOut137 happy_x_1 of { happy_var_1 -> -	happyIn136-		 (GuardedRhss (snd happy_var_1) (reverse $ fst happy_var_1)-	)}--happyReduce_314 = happySpecReduce_2  126# happyReduction_314-happyReduction_314 happy_x_2-	happy_x_1-	 =  case happyOut137 happy_x_1 of { happy_var_1 -> -	case happyOut138 happy_x_2 of { happy_var_2 -> -	happyIn137-		 ((happy_var_2 : fst happy_var_1, snd happy_var_1 <++> ann happy_var_2)-	)}}--happyReduce_315 = happySpecReduce_1  126# happyReduction_315-happyReduction_315 happy_x_1-	 =  case happyOut138 happy_x_1 of { happy_var_1 -> -	happyIn137-		 (([happy_var_1],ann happy_var_1)-	)}--happyReduce_316 = happyMonadReduce 4# 127# happyReduction_316-happyReduction_316 (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 { (Loc happy_var_1 Bar) -> -	case happyOut175 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 Equals) -> -	case happyOut139 happy_x_4 of { happy_var_4 -> -	( do { checkPatternGuards (fst happy_var_2);-                                       return $ GuardedRhs (nIS happy_var_1 <++> ann happy_var_4 <** (happy_var_1:snd happy_var_2 ++ [happy_var_3])) (reverse (fst happy_var_2)) happy_var_4 })}}}}-	) (\r -> happyReturn (happyIn138 r))--happyReduce_317 = happyMonadReduce 1# 128# happyReduction_317-happyReduction_317 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut140 happy_x_1 of { happy_var_1 -> -	( checkExpr happy_var_1)}-	) (\r -> happyReturn (happyIn139 r))--happyReduce_318 = happySpecReduce_3  129# happyReduction_318-happyReduction_318 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut143 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 DoubleColon) -> -	case happyOut88 happy_x_3 of { happy_var_3 -> -	happyIn140-		 (ExpTypeSig      (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3-	)}}}--happyReduce_319 = happySpecReduce_1  129# happyReduction_319-happyReduction_319 happy_x_1-	 =  case happyOut141 happy_x_1 of { happy_var_1 -> -	happyIn140-		 (happy_var_1-	)}--happyReduce_320 = happySpecReduce_2  129# happyReduction_320-happyReduction_320 happy_x_2-	happy_x_1-	 =  case happyOut143 happy_x_1 of { happy_var_1 -> -	case happyOut207 happy_x_2 of { happy_var_2 -> -	happyIn140-		 (PostOp          (happy_var_1 <> happy_var_2)          happy_var_1 happy_var_2-	)}}--happyReduce_321 = happySpecReduce_3  129# happyReduction_321-happyReduction_321 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut143 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftArrowTail) -> -	case happyOut140 happy_x_3 of { happy_var_3 -> -	happyIn140-		 (LeftArrApp      (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3-	)}}}--happyReduce_322 = happySpecReduce_3  129# happyReduction_322-happyReduction_322 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut143 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 RightArrowTail) -> -	case happyOut140 happy_x_3 of { happy_var_3 -> -	happyIn140-		 (RightArrApp     (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3-	)}}}--happyReduce_323 = happySpecReduce_3  129# happyReduction_323-happyReduction_323 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut143 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftDblArrowTail) -> -	case happyOut140 happy_x_3 of { happy_var_3 -> -	happyIn140-		 (LeftArrHighApp  (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3-	)}}}--happyReduce_324 = happySpecReduce_3  129# happyReduction_324-happyReduction_324 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut143 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 RightDblArrowTail) -> -	case happyOut140 happy_x_3 of { happy_var_3 -> -	happyIn140-		 (RightArrHighApp (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3-	)}}}--happyReduce_325 = happySpecReduce_1  130# happyReduction_325-happyReduction_325 happy_x_1-	 =  case happyOut142 happy_x_1 of { happy_var_1 -> -	happyIn141-		 (happy_var_1-	)}--happyReduce_326 = happySpecReduce_1  130# happyReduction_326-happyReduction_326 happy_x_1-	 =  case happyOut143 happy_x_1 of { happy_var_1 -> -	happyIn141-		 (happy_var_1-	)}--happyReduce_327 = happySpecReduce_3  131# happyReduction_327-happyReduction_327 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut143 happy_x_1 of { happy_var_1 -> -	case happyOut207 happy_x_2 of { happy_var_2 -> -	case happyOut144 happy_x_3 of { happy_var_3 -> -	happyIn142-		 (InfixApp (happy_var_1 <> happy_var_3) happy_var_1 happy_var_2 happy_var_3-	)}}}--happyReduce_328 = happySpecReduce_1  131# happyReduction_328-happyReduction_328 happy_x_1-	 =  case happyOut144 happy_x_1 of { happy_var_1 -> -	happyIn142-		 (happy_var_1-	)}--happyReduce_329 = happySpecReduce_3  132# happyReduction_329-happyReduction_329 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut143 happy_x_1 of { happy_var_1 -> -	case happyOut207 happy_x_2 of { happy_var_2 -> -	case happyOut147 happy_x_3 of { happy_var_3 -> -	happyIn143-		 (InfixApp (happy_var_1 <> happy_var_3) happy_var_1 happy_var_2 happy_var_3-	)}}}--happyReduce_330 = happySpecReduce_1  132# happyReduction_330-happyReduction_330 happy_x_1-	 =  case happyOut147 happy_x_1 of { happy_var_1 -> -	happyIn143-		 (happy_var_1-	)}--happyReduce_331 = happyReduce 4# 133# happyReduction_331-happyReduction_331 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 Backslash) -> -	case happyOut150 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightArrow) -> -	case happyOut140 happy_x_4 of { happy_var_4 -> -	happyIn144-		 (Lambda (nIS happy_var_1 <++> ann happy_var_4 <** [happy_var_1,happy_var_3]) (reverse happy_var_2) happy_var_4-	) `HappyStk` happyRest}}}}--happyReduce_332 = happyReduce 4# 133# happyReduction_332-happyReduction_332 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Let) -> -	case happyOut61 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 KW_In) -> -	case happyOut140 happy_x_4 of { happy_var_4 -> -	happyIn144-		 (Let    (nIS happy_var_1 <++> ann happy_var_4 <** [happy_var_1,happy_var_3])    happy_var_2 happy_var_4-	) `HappyStk` happyRest}}}}--happyReduce_333 = happyReduce 8# 133# happyReduction_333-happyReduction_333 (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 happyOutTok happy_x_1 of { (Loc happy_var_1 KW_If) -> -	case happyOut140 happy_x_2 of { happy_var_2 -> -	case happyOut145 happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { (Loc happy_var_4 KW_Then) -> -	case happyOut140 happy_x_5 of { happy_var_5 -> -	case happyOut145 happy_x_6 of { happy_var_6 -> -	case happyOutTok happy_x_7 of { (Loc happy_var_7 KW_Else) -> -	case happyOut140 happy_x_8 of { happy_var_8 -> -	happyIn144-		 (If     (nIS happy_var_1 <++> ann happy_var_8 <** (happy_var_1:happy_var_3 ++ happy_var_4:happy_var_6 ++ [happy_var_7])) happy_var_2 happy_var_5 happy_var_8-	) `HappyStk` happyRest}}}}}}}}--happyReduce_334 = happyReduce 4# 133# happyReduction_334-happyReduction_334 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Proc) -> -	case happyOut151 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightArrow) -> -	case happyOut140 happy_x_4 of { happy_var_4 -> -	happyIn144-		 (Proc   (nIS happy_var_1 <++> ann happy_var_4 <** [happy_var_1,happy_var_3])    happy_var_2 happy_var_4-	) `HappyStk` happyRest}}}}--happyReduce_335 = happySpecReduce_1  133# happyReduction_335-happyReduction_335 happy_x_1-	 =  case happyOut148 happy_x_1 of { happy_var_1 -> -	happyIn144-		 (happy_var_1-	)}--happyReduce_336 = happyMonadReduce 1# 134# happyReduction_336-happyReduction_336 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 SemiColon) -> -	( checkEnabled DoAndIfThenElse >> return [happy_var_1])}-	) (\r -> happyReturn (happyIn145 r))--happyReduce_337 = happySpecReduce_0  134# happyReduction_337-happyReduction_337  =  happyIn145-		 ([]-	)--happyReduce_338 = happySpecReduce_1  135# happyReduction_338-happyReduction_338 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 SemiColon) -> -	happyIn146-		 ([happy_var_1]-	)}--happyReduce_339 = happySpecReduce_0  135# happyReduction_339-happyReduction_339  =  happyIn146-		 ([]-	)--happyReduce_340 = happyReduce 4# 136# 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 { (Loc happy_var_1 KW_Case) -> -	case happyOut140 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 KW_Of) -> -	case happyOut177 happy_x_4 of { happy_var_4 -> -	happyIn147-		 (let (als, inf, ss) = happy_var_4 in Case (nIS happy_var_1 <++> inf <** (happy_var_1:happy_var_3:ss)) happy_var_2 als-	) `HappyStk` happyRest}}}}--happyReduce_341 = happySpecReduce_2  136# happyReduction_341-happyReduction_341 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Minus) -> -	case happyOut149 happy_x_2 of { happy_var_2 -> -	happyIn147-		 (NegApp (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2-	)}}--happyReduce_342 = happySpecReduce_2  136# happyReduction_342-happyReduction_342 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Do) -> -	case happyOut185 happy_x_2 of { happy_var_2 -> -	happyIn147-		 (let (sts, inf, ss) = happy_var_2 in Do   (nIS happy_var_1 <++> inf <** happy_var_1:ss) sts-	)}}--happyReduce_343 = happySpecReduce_2  136# happyReduction_343-happyReduction_343 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_MDo) -> -	case happyOut185 happy_x_2 of { happy_var_2 -> -	happyIn147-		 (let (sts, inf, ss) = happy_var_2 in MDo  (nIS happy_var_1 <++> inf <** happy_var_1:ss) sts-	)}}--happyReduce_344 = happySpecReduce_1  136# happyReduction_344-happyReduction_344 happy_x_1-	 =  case happyOut149 happy_x_1 of { happy_var_1 -> -	happyIn147-		 (happy_var_1-	)}--happyReduce_345 = happyReduce 4# 137# happyReduction_345-happyReduction_345 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 CORE) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 PragmaEnd) -> -	case happyOut140 happy_x_4 of { happy_var_4 -> -	happyIn148-		 (let Loc l (StringTok (s,_)) = happy_var_2 in CorePragma (nIS happy_var_1 <++> ann happy_var_4 <** [l,happy_var_3]) s happy_var_4-	) `HappyStk` happyRest}}}}--happyReduce_346 = happyReduce 4# 137# happyReduction_346-happyReduction_346 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 SCC) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 PragmaEnd) -> -	case happyOut140 happy_x_4 of { happy_var_4 -> -	happyIn148-		 (let Loc l (StringTok (s,_)) = happy_var_2 in SCCPragma  (nIS happy_var_1 <++> ann happy_var_4 <** [l,happy_var_3]) s happy_var_4-	) `HappyStk` happyRest}}}}--happyReduce_347 = happyReduce 11# 137# happyReduction_347-happyReduction_347 (happy_x_11 `HappyStk`-	happy_x_10 `HappyStk`-	happy_x_9 `HappyStk`-	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 happyOutTok happy_x_1 of { (Loc happy_var_1 GENERATED) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { (Loc happy_var_4 Colon) -> -	case happyOutTok happy_x_5 of { happy_var_5 -> -	case happyOutTok happy_x_6 of { (Loc happy_var_6 Minus) -> -	case happyOutTok happy_x_7 of { happy_var_7 -> -	case happyOutTok happy_x_8 of { (Loc happy_var_8 Colon) -> -	case happyOutTok happy_x_9 of { happy_var_9 -> -	case happyOutTok happy_x_10 of { (Loc happy_var_10 PragmaEnd) -> -	case happyOut140 happy_x_11 of { happy_var_11 -> -	happyIn148-		 (let { Loc l0 (StringTok (s,_)) = happy_var_2;-                                                  Loc l1 (IntTok (i1,_))   = happy_var_3;-                                                  Loc l2 (IntTok (i2,_))   = happy_var_5;-                                                  Loc l3 (IntTok (i3,_))   = happy_var_7;-                                                  Loc l4 (IntTok (i4,_))   = happy_var_9}-                                             in GenPragma (nIS happy_var_1 <++> ann happy_var_11 <** [happy_var_1,l0,l1,happy_var_4,l2,happy_var_6,l3,happy_var_8,l4,happy_var_10])-                                                      s (fromInteger i1, fromInteger i2)-                                                        (fromInteger i3, fromInteger i4) happy_var_11-	) `HappyStk` happyRest}}}}}}}}}}}--happyReduce_348 = happySpecReduce_2  138# happyReduction_348-happyReduction_348 happy_x_2-	happy_x_1-	 =  case happyOut149 happy_x_1 of { happy_var_1 -> -	case happyOut152 happy_x_2 of { happy_var_2 -> -	happyIn149-		 (App (happy_var_1 <> happy_var_2) happy_var_1 happy_var_2-	)}}--happyReduce_349 = happySpecReduce_1  138# happyReduction_349-happyReduction_349 happy_x_1-	 =  case happyOut152 happy_x_1 of { happy_var_1 -> -	happyIn149-		 (happy_var_1-	)}--happyReduce_350 = happySpecReduce_2  139# happyReduction_350-happyReduction_350 happy_x_2-	happy_x_1-	 =  case happyOut150 happy_x_1 of { happy_var_1 -> -	case happyOut151 happy_x_2 of { happy_var_2 -> -	happyIn150-		 (happy_var_2 : happy_var_1-	)}}--happyReduce_351 = happySpecReduce_1  139# happyReduction_351-happyReduction_351 happy_x_1-	 =  case happyOut151 happy_x_1 of { happy_var_1 -> -	happyIn150-		 ([happy_var_1]-	)}--happyReduce_352 = happyMonadReduce 1# 140# happyReduction_352-happyReduction_352 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut152 happy_x_1 of { happy_var_1 -> -	( checkPattern happy_var_1)}-	) (\r -> happyReturn (happyIn151 r))--happyReduce_353 = happyMonadReduce 2# 140# happyReduction_353-happyReduction_353 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 Exclamation) -> -	case happyOut152 happy_x_2 of { happy_var_2 -> -	( checkPattern (BangPat (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2))}}-	) (\r -> happyReturn (happyIn151 r))--happyReduce_354 = happyMonadReduce 3# 141# happyReduction_354-happyReduction_354 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut197 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 At) -> -	case happyOut152 happy_x_3 of { happy_var_3 -> -	( do { n <- checkUnQual happy_var_1;-                                              return (AsPat (happy_var_1 <> happy_var_3 <** [happy_var_2]) n happy_var_3) })}}}-	) (\r -> happyReturn (happyIn152 r))--happyReduce_355 = happyMonadReduce 3# 141# happyReduction_355-happyReduction_355 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut197 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 RPCAt) -> -	case happyOut152 happy_x_3 of { happy_var_3 -> -	( do { n <- checkUnQual happy_var_1;-                                              return (CAsRP (happy_var_1 <> happy_var_3 <** [happy_var_2]) n happy_var_3) })}}}-	) (\r -> happyReturn (happyIn152 r))--happyReduce_356 = happySpecReduce_2  141# happyReduction_356-happyReduction_356 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Tilde) -> -	case happyOut152 happy_x_2 of { happy_var_2 -> -	happyIn152-		 (IrrPat (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2-	)}}--happyReduce_357 = happySpecReduce_1  141# happyReduction_357-happyReduction_357 happy_x_1-	 =  case happyOut153 happy_x_1 of { happy_var_1 -> -	happyIn152-		 (happy_var_1-	)}--happyReduce_358 = happyMonadReduce 3# 142# happyReduction_358-happyReduction_358 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut153 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftCurly) -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightCurly) -> -	( liftM (amap (const (ann happy_var_1 <++> nIS happy_var_3 <** [happy_var_2,happy_var_3]))) $ mkRecConstrOrUpdate happy_var_1 [])}}}-	) (\r -> happyReturn (happyIn153 r))--happyReduce_359 = happyMonadReduce 4# 142# happyReduction_359-happyReduction_359 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut153 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftCurly) -> -	case happyOut189 happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { (Loc happy_var_4 RightCurly) -> -	( liftM (amap (const (ann happy_var_1 <++> nIS happy_var_4 <** (happy_var_2:reverse (snd happy_var_3) ++ [happy_var_4]))))-                                              $ mkRecConstrOrUpdate happy_var_1 (reverse (fst happy_var_3)))}}}}-	) (\r -> happyReturn (happyIn153 r))--happyReduce_360 = happyReduce 4# 142# happyReduction_360-happyReduction_360 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut197 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftCurlyBar) -> -	case happyOut79 happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { (Loc happy_var_4 RightCurlyBar) -> -	happyIn153-		 (ExplTypeArg (ann happy_var_1 <++> nIS happy_var_4 <** [happy_var_2,happy_var_4]) happy_var_1 happy_var_3-	) `HappyStk` happyRest}}}}--happyReduce_361 = happySpecReduce_1  142# happyReduction_361-happyReduction_361 happy_x_1-	 =  case happyOut154 happy_x_1 of { happy_var_1 -> -	happyIn153-		 (happy_var_1-	)}--happyReduce_362 = happySpecReduce_1  143# happyReduction_362-happyReduction_362 happy_x_1-	 =  case happyOut198 happy_x_1 of { happy_var_1 -> -	happyIn154-		 (IPVar (ann happy_var_1) happy_var_1-	)}--happyReduce_363 = happySpecReduce_1  143# happyReduction_363-happyReduction_363 happy_x_1-	 =  case happyOut197 happy_x_1 of { happy_var_1 -> -	happyIn154-		 (Var (ann happy_var_1) happy_var_1-	)}--happyReduce_364 = happySpecReduce_1  143# happyReduction_364-happyReduction_364 happy_x_1-	 =  case happyOut194 happy_x_1 of { happy_var_1 -> -	happyIn154-		 (happy_var_1-	)}--happyReduce_365 = happySpecReduce_1  143# happyReduction_365-happyReduction_365 happy_x_1-	 =  case happyOut223 happy_x_1 of { happy_var_1 -> -	happyIn154-		 (Lit (ann happy_var_1) happy_var_1-	)}--happyReduce_366 = happySpecReduce_3  143# happyReduction_366-happyReduction_366 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> -	case happyOut156 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> -	happyIn154-		 (Paren (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3]) happy_var_2-	)}}}--happyReduce_367 = happySpecReduce_3  143# happyReduction_367-happyReduction_367 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> -	case happyOut156 happy_x_2 of { happy_var_2 -> -	case happyOut157 happy_x_3 of { happy_var_3 -> -	happyIn154-		 (TupleSection (happy_var_1 <^^> head (snd happy_var_3) <** happy_var_1:reverse (snd happy_var_3)) (Just happy_var_2 : fst happy_var_3)-	)}}}--happyReduce_368 = happyReduce 4# 143# happyReduction_368-happyReduction_368 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> -	case happyOut155 happy_x_2 of { happy_var_2 -> -	case happyOut156 happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { (Loc happy_var_4 RightParen) -> -	happyIn154-		 (TupleSection (happy_var_1 <^^> happy_var_4 <** happy_var_1:reverse (happy_var_4:happy_var_2))-                                                      (replicate (length happy_var_2) Nothing ++ [Just happy_var_3])-	) `HappyStk` happyRest}}}}--happyReduce_369 = happyReduce 4# 143# happyReduction_369-happyReduction_369 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> -	case happyOut155 happy_x_2 of { happy_var_2 -> -	case happyOut156 happy_x_3 of { happy_var_3 -> -	case happyOut157 happy_x_4 of { happy_var_4 -> -	happyIn154-		 (TupleSection (happy_var_1 <^^> head (snd happy_var_4) <** happy_var_1:reverse (snd happy_var_4 ++ happy_var_2))-                                                      (replicate (length happy_var_2) Nothing ++ Just happy_var_3 : fst happy_var_4)-	) `HappyStk` happyRest}}}}--happyReduce_370 = happySpecReduce_3  143# happyReduction_370-happyReduction_370 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftSquare) -> -	case happyOut169 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightSquare) -> -	happyIn154-		 (amap (\l -> l <** [happy_var_3]) $ happy_var_2 (happy_var_1 <^^> happy_var_3 <** [happy_var_1])-	)}}}--happyReduce_371 = happySpecReduce_1  143# happyReduction_371-happyReduction_371 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Underscore) -> -	happyIn154-		 (WildCard (nIS happy_var_1)-	)}--happyReduce_372 = happyMonadReduce 3# 143# happyReduction_372-happyReduction_372 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> -	case happyOut159 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> -	( checkEnabled RegularPatterns >> return (Paren (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3]) happy_var_2))}}}-	) (\r -> happyReturn (happyIn154 r))--happyReduce_373 = happySpecReduce_3  143# happyReduction_373-happyReduction_373 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 RPGuardOpen) -> -	case happyOut158 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 RPGuardClose) -> -	happyIn154-		 (SeqRP (happy_var_1 <^^> happy_var_3 <** (happy_var_1:reverse (snd happy_var_2) ++ [happy_var_3])) $ reverse (fst happy_var_2)-	)}}}--happyReduce_374 = happyReduce 5# 143# happyReduction_374-happyReduction_374 (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 { (Loc happy_var_1 RPGuardOpen) -> -	case happyOut140 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 Bar) -> -	case happyOut175 happy_x_4 of { happy_var_4 -> -	case happyOutTok happy_x_5 of { (Loc happy_var_5 RPGuardClose) -> -	happyIn154-		 (GuardRP (happy_var_1 <^^> happy_var_5 <** (happy_var_1:happy_var_3 : snd happy_var_4 ++ [happy_var_5])) happy_var_2 $ (reverse $ fst happy_var_4)-	) `HappyStk` happyRest}}}}}--happyReduce_375 = happySpecReduce_1  143# happyReduction_375-happyReduction_375 happy_x_1-	 =  case happyOut160 happy_x_1 of { happy_var_1 -> -	happyIn154-		 (happy_var_1-	)}--happyReduce_376 = happySpecReduce_1  143# happyReduction_376-happyReduction_376 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn154-		 (let Loc l (THIdEscape s) = happy_var_1 in SpliceExp (nIS l) $ IdSplice (nIS l) s-	)}--happyReduce_377 = happySpecReduce_3  143# happyReduction_377-happyReduction_377 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 THParenEscape) -> -	case happyOut139 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> -	happyIn154-		 (SpliceExp  (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3]) $ ParenSplice (ann happy_var_2) happy_var_2-	)}}}--happyReduce_378 = happySpecReduce_3  143# happyReduction_378-happyReduction_378 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 THExpQuote) -> -	case happyOut139 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 THCloseQuote) -> -	happyIn154-		 (BracketExp (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3]) $ ExpBracket  (ann happy_var_2) happy_var_2-	)}}}--happyReduce_379 = happyMonadReduce 3# 143# happyReduction_379-happyReduction_379 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 THPatQuote) -> -	case happyOut141 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 THCloseQuote) -> -	( do { p <- checkPattern happy_var_2;-                                              return $ BracketExp (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3]) $ PatBracket (ann p) p })}}}-	) (\r -> happyReturn (happyIn154 r))--happyReduce_380 = happySpecReduce_3  143# happyReduction_380-happyReduction_380 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 THTypQuote) -> -	case happyOut88 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 THCloseQuote) -> -	happyIn154-		 (let l = happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3] in BracketExp l $ TypeBracket l happy_var_2-	)}}}--happyReduce_381 = happyReduce 5# 143# happyReduction_381-happyReduction_381 (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 { (Loc happy_var_1 THDecQuote) -> -	case happyOut48 happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_5 of { (Loc happy_var_5 THCloseQuote) -> -	happyIn154-		 (let l = happy_var_1 <^^> happy_var_5 <** (happy_var_1:snd happy_var_3 ++ [happy_var_5]) in BracketExp l $ DeclBracket l (fst happy_var_3)-	) `HappyStk` happyRest}}}--happyReduce_382 = happySpecReduce_2  143# happyReduction_382-happyReduction_382 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 THVarQuote) -> -	case happyOut197 happy_x_2 of { happy_var_2 -> -	happyIn154-		 (VarQuote (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2-	)}}--happyReduce_383 = happySpecReduce_2  143# happyReduction_383-happyReduction_383 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 THVarQuote) -> -	case happyOut200 happy_x_2 of { happy_var_2 -> -	happyIn154-		 (VarQuote (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2-	)}}--happyReduce_384 = happySpecReduce_2  143# happyReduction_384-happyReduction_384 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 THTyQuote) -> -	case happyOut229 happy_x_2 of { happy_var_2 -> -	happyIn154-		 (TypQuote (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) (UnQual (ann happy_var_2) happy_var_2)-	)}}--happyReduce_385 = happySpecReduce_2  143# happyReduction_385-happyReduction_385 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 THTyQuote) -> -	case happyOut85 happy_x_2 of { happy_var_2 -> -	happyIn154-		 (TypQuote (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2-	)}}--happyReduce_386 = happySpecReduce_1  143# happyReduction_386-happyReduction_386 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn154-		 (let Loc l (THQuasiQuote (n,q)) = happy_var_1 in QuasiQuote (nIS l) n q-	)}--happyReduce_387 = happySpecReduce_2  144# happyReduction_387-happyReduction_387 happy_x_2-	happy_x_1-	 =  case happyOut155 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> -	happyIn155-		 (happy_var_2 : happy_var_1-	)}}--happyReduce_388 = happySpecReduce_1  144# happyReduction_388-happyReduction_388 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Comma) -> -	happyIn155-		 ([happy_var_1]-	)}--happyReduce_389 = happySpecReduce_1  145# happyReduction_389-happyReduction_389 happy_x_1-	 =  case happyOut140 happy_x_1 of { happy_var_1 -> -	happyIn156-		 (happy_var_1-	)}--happyReduce_390 = happySpecReduce_2  145# happyReduction_390-happyReduction_390 happy_x_2-	happy_x_1-	 =  case happyOut208 happy_x_1 of { happy_var_1 -> -	case happyOut141 happy_x_2 of { happy_var_2 -> -	happyIn156-		 (PreOp (happy_var_1 <> happy_var_2) happy_var_1 happy_var_2-	)}}--happyReduce_391 = happyMonadReduce 3# 145# happyReduction_391-happyReduction_391 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut140 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 RightArrow) -> -	case happyOut140 happy_x_3 of { happy_var_3 -> -	( do {checkEnabled ViewPatterns;-                                             return $ ViewPat (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3})}}}-	) (\r -> happyReturn (happyIn156 r))--happyReduce_392 = happySpecReduce_3  146# happyReduction_392-happyReduction_392 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut155 happy_x_1 of { happy_var_1 -> -	case happyOut156 happy_x_2 of { happy_var_2 -> -	case happyOut157 happy_x_3 of { happy_var_3 -> -	happyIn157-		 (let (mes, ss) = happy_var_3 in (replicate (length happy_var_1 - 1) Nothing ++ Just happy_var_2 : mes, ss ++ happy_var_1)-	)}}}--happyReduce_393 = happySpecReduce_3  146# happyReduction_393-happyReduction_393 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut155 happy_x_1 of { happy_var_1 -> -	case happyOut156 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> -	happyIn157-		 ((replicate (length happy_var_1 - 1) Nothing ++ [Just happy_var_2], happy_var_3 : happy_var_1)-	)}}}--happyReduce_394 = happySpecReduce_2  146# happyReduction_394-happyReduction_394 happy_x_2-	happy_x_1-	 =  case happyOut155 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 RightParen) -> -	happyIn157-		 ((replicate (length happy_var_1) Nothing, happy_var_2 : happy_var_1)-	)}}--happyReduce_395 = happySpecReduce_3  147# happyReduction_395-happyReduction_395 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut158 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> -	case happyOut140 happy_x_3 of { happy_var_3 -> -	happyIn158-		 ((happy_var_3 : fst happy_var_1, happy_var_2 : snd happy_var_1)-	)}}}--happyReduce_396 = happySpecReduce_1  147# happyReduction_396-happyReduction_396 happy_x_1-	 =  case happyOut140 happy_x_1 of { happy_var_1 -> -	happyIn158-		 (([happy_var_1],[])-	)}--happyReduce_397 = happySpecReduce_3  148# happyReduction_397-happyReduction_397 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut140 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 Bar) -> -	case happyOut159 happy_x_3 of { happy_var_3 -> -	happyIn159-		 (EitherRP (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3-	)}}}--happyReduce_398 = happySpecReduce_3  148# happyReduction_398-happyReduction_398 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut140 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 Bar) -> -	case happyOut140 happy_x_3 of { happy_var_3 -> -	happyIn159-		 (EitherRP (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3-	)}}}--happyReduce_399 = happyMonadReduce 10# 149# happyReduction_399-happyReduction_399 (happy_x_10 `HappyStk`-	happy_x_9 `HappyStk`-	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) tk-	 = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 XStdTagOpen) -> -	case happyOut163 happy_x_2 of { happy_var_2 -> -	case happyOut166 happy_x_3 of { happy_var_3 -> -	case happyOut168 happy_x_4 of { happy_var_4 -> -	case happyOutTok happy_x_5 of { (Loc happy_var_5 XStdTagClose) -> -	case happyOut161 happy_x_6 of { happy_var_6 -> -	case happyOut146 happy_x_7 of { happy_var_7 -> -	case happyOutTok happy_x_8 of { (Loc happy_var_8 XCloseTagOpen) -> -	case happyOut163 happy_x_9 of { happy_var_9 -> -	case happyOutTok happy_x_10 of { (Loc happy_var_10 XStdTagClose) -> -	( do { n <- checkEqNames happy_var_2 happy_var_9;-                                                                       let { cn = reverse happy_var_6;-                                                                             as = reverse happy_var_3;-                                                                             l  = happy_var_1 <^^> happy_var_10 <** [happy_var_1,happy_var_5] ++ happy_var_7 ++ [happy_var_8,srcInfoSpan (ann happy_var_9),happy_var_10] };-                                                                       return $ XTag l n as happy_var_4 cn })}}}}}}}}}}-	) (\r -> happyReturn (happyIn160 r))--happyReduce_400 = happyReduce 5# 149# happyReduction_400-happyReduction_400 (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 { (Loc happy_var_1 XStdTagOpen) -> -	case happyOut163 happy_x_2 of { happy_var_2 -> -	case happyOut166 happy_x_3 of { happy_var_3 -> -	case happyOut168 happy_x_4 of { happy_var_4 -> -	case happyOutTok happy_x_5 of { (Loc happy_var_5 XEmptyTagClose) -> -	happyIn160-		 (XETag   (happy_var_1 <^^> happy_var_5 <** [happy_var_1,happy_var_5]) happy_var_2 (reverse happy_var_3) happy_var_4-	) `HappyStk` happyRest}}}}}--happyReduce_401 = happySpecReduce_3  149# happyReduction_401-happyReduction_401 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 XCodeTagOpen) -> -	case happyOut140 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 XCodeTagClose) -> -	happyIn160-		 (XExpTag (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3]) happy_var_2-	)}}}--happyReduce_402 = happyReduce 5# 149# happyReduction_402-happyReduction_402 (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 { (Loc happy_var_1 XChildTagOpen) -> -	case happyOut161 happy_x_2 of { happy_var_2 -> -	case happyOut146 happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { (Loc happy_var_4 XCloseTagOpen) -> -	case happyOutTok happy_x_5 of { (Loc happy_var_5 XCodeTagClose) -> -	happyIn160-		 (XChildTag (happy_var_1 <^^> happy_var_5 <** (happy_var_1:happy_var_3++[happy_var_4,happy_var_5])) (reverse happy_var_2)-	) `HappyStk` happyRest}}}}}--happyReduce_403 = happySpecReduce_2  150# happyReduction_403-happyReduction_403 happy_x_2-	happy_x_1-	 =  case happyOut161 happy_x_1 of { happy_var_1 -> -	case happyOut162 happy_x_2 of { happy_var_2 -> -	happyIn161-		 (happy_var_2 : happy_var_1-	)}}--happyReduce_404 = happySpecReduce_0  150# happyReduction_404-happyReduction_404  =  happyIn161-		 ([]-	)--happyReduce_405 = happySpecReduce_1  151# happyReduction_405-happyReduction_405 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn162-		 (let Loc l (XPCDATA pcd) = happy_var_1 in XPcdata (nIS l) pcd-	)}--happyReduce_406 = happySpecReduce_3  151# happyReduction_406-happyReduction_406 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 XRPatOpen) -> -	case happyOut158 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 XRPatClose) -> -	happyIn162-		 (XRPats (happy_var_1 <^^> happy_var_3 <** (snd happy_var_2 ++ [happy_var_1,happy_var_3])) $ reverse (fst happy_var_2)-	)}}}--happyReduce_407 = happySpecReduce_1  151# happyReduction_407-happyReduction_407 happy_x_1-	 =  case happyOut160 happy_x_1 of { happy_var_1 -> -	happyIn162-		 (happy_var_1-	)}--happyReduce_408 = happySpecReduce_3  152# happyReduction_408-happyReduction_408 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut164 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 Colon) -> -	case happyOut164 happy_x_3 of { happy_var_3 -> -	happyIn163-		 (let {Loc l1 s1 = happy_var_1; Loc l2 s2 = happy_var_3}-                                         in XDomName (nIS l1 <++> nIS l2 <** [l1,happy_var_2,l2]) s1 s2-	)}}}--happyReduce_409 = happySpecReduce_1  152# happyReduction_409-happyReduction_409 happy_x_1-	 =  case happyOut164 happy_x_1 of { happy_var_1 -> -	happyIn163-		 (let Loc l str = happy_var_1 in XName (nIS l) str-	)}--happyReduce_410 = happySpecReduce_1  153# happyReduction_410-happyReduction_410 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn164-		 (let Loc l (VarId  s) = happy_var_1 in Loc l s-	)}--happyReduce_411 = happySpecReduce_1  153# happyReduction_411-happyReduction_411 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn164-		 (let Loc l (ConId  s) = happy_var_1 in Loc l s-	)}--happyReduce_412 = happySpecReduce_1  153# happyReduction_412-happyReduction_412 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn164-		 (let Loc l (DVarId s) = happy_var_1 in Loc l $ mkDVar s-	)}--happyReduce_413 = happySpecReduce_1  153# happyReduction_413-happyReduction_413 happy_x_1-	 =  case happyOut165 happy_x_1 of { happy_var_1 -> -	happyIn164-		 (happy_var_1-	)}--happyReduce_414 = happySpecReduce_1  154# happyReduction_414-happyReduction_414 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Type) -> -	happyIn165-		 (Loc happy_var_1 "type"-	)}--happyReduce_415 = happySpecReduce_1  154# happyReduction_415-happyReduction_415 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Class) -> -	happyIn165-		 (Loc happy_var_1 "class"-	)}--happyReduce_416 = happySpecReduce_1  154# happyReduction_416-happyReduction_416 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Data) -> -	happyIn165-		 (Loc happy_var_1 "data"-	)}--happyReduce_417 = happySpecReduce_1  154# happyReduction_417-happyReduction_417 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Foreign) -> -	happyIn165-		 (Loc happy_var_1 "foreign"-	)}--happyReduce_418 = happySpecReduce_1  154# happyReduction_418-happyReduction_418 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Export) -> -	happyIn165-		 (Loc happy_var_1 "export"-	)}--happyReduce_419 = happySpecReduce_1  154# happyReduction_419-happyReduction_419 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Safe) -> -	happyIn165-		 (Loc happy_var_1 "safe"-	)}--happyReduce_420 = happySpecReduce_1  154# happyReduction_420-happyReduction_420 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Unsafe) -> -	happyIn165-		 (Loc happy_var_1 "unsafe"-	)}--happyReduce_421 = happySpecReduce_1  154# happyReduction_421-happyReduction_421 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Threadsafe) -> -	happyIn165-		 (Loc happy_var_1 "threadsafe"-	)}--happyReduce_422 = happySpecReduce_1  154# happyReduction_422-happyReduction_422 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_StdCall) -> -	happyIn165-		 (Loc happy_var_1 "stdcall"-	)}--happyReduce_423 = happySpecReduce_1  154# happyReduction_423-happyReduction_423 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_CCall) -> -	happyIn165-		 (Loc happy_var_1 "ccall"-	)}--happyReduce_424 = happySpecReduce_1  154# happyReduction_424-happyReduction_424 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_CPlusPlus) -> -	happyIn165-		 (Loc happy_var_1 "cplusplus"-	)}--happyReduce_425 = happySpecReduce_1  154# happyReduction_425-happyReduction_425 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_DotNet) -> -	happyIn165-		 (Loc happy_var_1 "dotnet"-	)}--happyReduce_426 = happySpecReduce_1  154# happyReduction_426-happyReduction_426 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Jvm) -> -	happyIn165-		 (Loc happy_var_1 "jvm"-	)}--happyReduce_427 = happySpecReduce_1  154# happyReduction_427-happyReduction_427 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Js) -> -	happyIn165-		 (Loc happy_var_1 "js"-	)}--happyReduce_428 = happySpecReduce_1  154# happyReduction_428-happyReduction_428 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_As) -> -	happyIn165-		 (Loc happy_var_1 "as"-	)}--happyReduce_429 = happySpecReduce_1  154# happyReduction_429-happyReduction_429 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_By) -> -	happyIn165-		 (Loc happy_var_1 "by"-	)}--happyReduce_430 = happySpecReduce_1  154# happyReduction_430-happyReduction_430 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Case) -> -	happyIn165-		 (Loc happy_var_1 "case"-	)}--happyReduce_431 = happySpecReduce_1  154# happyReduction_431-happyReduction_431 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Default) -> -	happyIn165-		 (Loc happy_var_1 "default"-	)}--happyReduce_432 = happySpecReduce_1  154# happyReduction_432-happyReduction_432 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Deriving) -> -	happyIn165-		 (Loc happy_var_1 "deriving"-	)}--happyReduce_433 = happySpecReduce_1  154# happyReduction_433-happyReduction_433 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Do) -> -	happyIn165-		 (Loc happy_var_1 "do"-	)}--happyReduce_434 = happySpecReduce_1  154# happyReduction_434-happyReduction_434 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Else) -> -	happyIn165-		 (Loc happy_var_1 "else"-	)}--happyReduce_435 = happySpecReduce_1  154# happyReduction_435-happyReduction_435 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Family) -> -	happyIn165-		 (Loc happy_var_1 "family"-	)}--happyReduce_436 = happySpecReduce_1  154# happyReduction_436-happyReduction_436 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Forall) -> -	happyIn165-		 (Loc happy_var_1 "forall"-	)}--happyReduce_437 = happySpecReduce_1  154# happyReduction_437-happyReduction_437 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Group) -> -	happyIn165-		 (Loc happy_var_1 "group"-	)}--happyReduce_438 = happySpecReduce_1  154# happyReduction_438-happyReduction_438 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Hiding) -> -	happyIn165-		 (Loc happy_var_1 "hiding"-	)}--happyReduce_439 = happySpecReduce_1  154# happyReduction_439-happyReduction_439 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_If) -> -	happyIn165-		 (Loc happy_var_1 "if"-	)}--happyReduce_440 = happySpecReduce_1  154# happyReduction_440-happyReduction_440 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Import) -> -	happyIn165-		 (Loc happy_var_1 "import"-	)}--happyReduce_441 = happySpecReduce_1  154# happyReduction_441-happyReduction_441 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_In) -> -	happyIn165-		 (Loc happy_var_1 "in"-	)}--happyReduce_442 = happySpecReduce_1  154# happyReduction_442-happyReduction_442 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Infix) -> -	happyIn165-		 (Loc happy_var_1 "infix"-	)}--happyReduce_443 = happySpecReduce_1  154# happyReduction_443-happyReduction_443 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_InfixL) -> -	happyIn165-		 (Loc happy_var_1 "infixl"-	)}--happyReduce_444 = happySpecReduce_1  154# happyReduction_444-happyReduction_444 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_InfixR) -> -	happyIn165-		 (Loc happy_var_1 "infixr"-	)}--happyReduce_445 = happySpecReduce_1  154# happyReduction_445-happyReduction_445 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Instance) -> -	happyIn165-		 (Loc happy_var_1 "instance"-	)}--happyReduce_446 = happySpecReduce_1  154# happyReduction_446-happyReduction_446 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Let) -> -	happyIn165-		 (Loc happy_var_1 "let"-	)}--happyReduce_447 = happySpecReduce_1  154# happyReduction_447-happyReduction_447 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_MDo) -> -	happyIn165-		 (Loc happy_var_1 "mdo"-	)}--happyReduce_448 = happySpecReduce_1  154# happyReduction_448-happyReduction_448 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Module) -> -	happyIn165-		 (Loc happy_var_1 "module"-	)}--happyReduce_449 = happySpecReduce_1  154# happyReduction_449-happyReduction_449 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_NewType) -> -	happyIn165-		 (Loc happy_var_1 "newtype"-	)}--happyReduce_450 = happySpecReduce_1  154# happyReduction_450-happyReduction_450 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Of) -> -	happyIn165-		 (Loc happy_var_1 "of"-	)}--happyReduce_451 = happySpecReduce_1  154# happyReduction_451-happyReduction_451 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Proc) -> -	happyIn165-		 (Loc happy_var_1 "proc"-	)}--happyReduce_452 = happySpecReduce_1  154# happyReduction_452-happyReduction_452 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Rec) -> -	happyIn165-		 (Loc happy_var_1 "rec"-	)}--happyReduce_453 = happySpecReduce_1  154# happyReduction_453-happyReduction_453 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Then) -> -	happyIn165-		 (Loc happy_var_1 "then"-	)}--happyReduce_454 = happySpecReduce_1  154# happyReduction_454-happyReduction_454 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Using) -> -	happyIn165-		 (Loc happy_var_1 "using"-	)}--happyReduce_455 = happySpecReduce_1  154# happyReduction_455-happyReduction_455 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Where) -> -	happyIn165-		 (Loc happy_var_1 "where"-	)}--happyReduce_456 = happySpecReduce_1  154# happyReduction_456-happyReduction_456 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Qualified) -> -	happyIn165-		 (Loc happy_var_1 "qualified"-	)}--happyReduce_457 = happySpecReduce_2  155# happyReduction_457-happyReduction_457 happy_x_2-	happy_x_1-	 =  case happyOut166 happy_x_1 of { happy_var_1 -> -	case happyOut167 happy_x_2 of { happy_var_2 -> -	happyIn166-		 (happy_var_2 : happy_var_1-	)}}--happyReduce_458 = happySpecReduce_0  155# happyReduction_458-happyReduction_458  =  happyIn166-		 ([]-	)--happyReduce_459 = happySpecReduce_3  156# happyReduction_459-happyReduction_459 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut163 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 Equals) -> -	case happyOut152 happy_x_3 of { happy_var_3 -> -	happyIn167-		 (XAttr (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3-	)}}}--happyReduce_460 = happySpecReduce_1  157# happyReduction_460-happyReduction_460 happy_x_1-	 =  case happyOut152 happy_x_1 of { happy_var_1 -> -	happyIn168-		 (Just happy_var_1-	)}--happyReduce_461 = happySpecReduce_0  157# happyReduction_461-happyReduction_461  =  happyIn168-		 (Nothing-	)--happyReduce_462 = happySpecReduce_1  158# happyReduction_462-happyReduction_462 happy_x_1-	 =  case happyOut156 happy_x_1 of { happy_var_1 -> -	happyIn169-		 (\l -> List l [happy_var_1]-	)}--happyReduce_463 = happySpecReduce_1  158# happyReduction_463-happyReduction_463 happy_x_1-	 =  case happyOut170 happy_x_1 of { happy_var_1 -> -	happyIn169-		 (\l -> let (ps,ss) = happy_var_1 in List (l <** reverse ss) (reverse ps)-	)}--happyReduce_464 = happySpecReduce_2  158# happyReduction_464-happyReduction_464 happy_x_2-	happy_x_1-	 =  case happyOut156 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 DotDot) -> -	happyIn169-		 (\l -> EnumFrom       (l <** [happy_var_2]) happy_var_1-	)}}--happyReduce_465 = happyReduce 4# 158# happyReduction_465-happyReduction_465 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut156 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> -	case happyOut140 happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { (Loc happy_var_4 DotDot) -> -	happyIn169-		 (\l -> EnumFromThen   (l <** [happy_var_2,happy_var_4]) happy_var_1 happy_var_3-	) `HappyStk` happyRest}}}}--happyReduce_466 = happySpecReduce_3  158# happyReduction_466-happyReduction_466 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut156 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 DotDot) -> -	case happyOut140 happy_x_3 of { happy_var_3 -> -	happyIn169-		 (\l -> EnumFromTo     (l <** [happy_var_2]) happy_var_1 happy_var_3-	)}}}--happyReduce_467 = happyReduce 5# 158# happyReduction_467-happyReduction_467 (happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut156 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> -	case happyOut140 happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { (Loc happy_var_4 DotDot) -> -	case happyOut140 happy_x_5 of { happy_var_5 -> -	happyIn169-		 (\l -> EnumFromThenTo (l <** [happy_var_2,happy_var_4]) happy_var_1 happy_var_3 happy_var_5-	) `HappyStk` happyRest}}}}}--happyReduce_468 = happySpecReduce_3  158# happyReduction_468-happyReduction_468 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut156 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 Bar) -> -	case happyOut171 happy_x_3 of { happy_var_3 -> -	happyIn169-		 (\l -> let (stss, ss) = happy_var_3 in ParComp (l <** (happy_var_2:ss)) happy_var_1 (reverse stss)-	)}}}--happyReduce_469 = happySpecReduce_3  159# happyReduction_469-happyReduction_469 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut170 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> -	case happyOut156 happy_x_3 of { happy_var_3 -> -	happyIn170-		 (let (es, ss) = happy_var_1 in (happy_var_3 : es, happy_var_2 : ss)-	)}}}--happyReduce_470 = happySpecReduce_3  159# happyReduction_470-happyReduction_470 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut156 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> -	case happyOut156 happy_x_3 of { happy_var_3 -> -	happyIn170-		 (([happy_var_3,happy_var_1], [happy_var_2])-	)}}}--happyReduce_471 = happySpecReduce_3  160# happyReduction_471-happyReduction_471 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut171 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 Bar) -> -	case happyOut172 happy_x_3 of { happy_var_3 -> -	happyIn171-		 (let { (stss, ss1) = happy_var_1;-                                              (sts, ss2) = happy_var_3 }-                                         in (reverse sts : stss, ss1 ++ [happy_var_2] ++ reverse ss2)-	)}}}--happyReduce_472 = happySpecReduce_1  160# happyReduction_472-happyReduction_472 happy_x_1-	 =  case happyOut172 happy_x_1 of { happy_var_1 -> -	happyIn171-		 (let (sts, ss) = happy_var_1 in ([reverse sts], reverse ss)-	)}--happyReduce_473 = happySpecReduce_3  161# happyReduction_473-happyReduction_473 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut172 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> -	case happyOut173 happy_x_3 of { happy_var_3 -> -	happyIn172-		 (let (sts, ss) = happy_var_1 in (happy_var_3 : sts, happy_var_2 : ss)-	)}}}--happyReduce_474 = happySpecReduce_1  161# happyReduction_474-happyReduction_474 happy_x_1-	 =  case happyOut173 happy_x_1 of { happy_var_1 -> -	happyIn172-		 (([happy_var_1],[])-	)}--happyReduce_475 = happySpecReduce_1  162# happyReduction_475-happyReduction_475 happy_x_1-	 =  case happyOut174 happy_x_1 of { happy_var_1 -> -	happyIn173-		 (happy_var_1-	)}--happyReduce_476 = happySpecReduce_1  162# happyReduction_476-happyReduction_476 happy_x_1-	 =  case happyOut176 happy_x_1 of { happy_var_1 -> -	happyIn173-		 (QualStmt (ann happy_var_1) happy_var_1-	)}--happyReduce_477 = happySpecReduce_2  163# happyReduction_477-happyReduction_477 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Then) -> -	case happyOut139 happy_x_2 of { happy_var_2 -> -	happyIn174-		 (ThenTrans    (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2-	)}}--happyReduce_478 = happyReduce 4# 163# happyReduction_478-happyReduction_478 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Then) -> -	case happyOut139 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 KW_By) -> -	case happyOut139 happy_x_4 of { happy_var_4 -> -	happyIn174-		 (ThenBy       (nIS happy_var_1 <++> ann happy_var_4 <** [happy_var_1,happy_var_3]) happy_var_2 happy_var_4-	) `HappyStk` happyRest}}}}--happyReduce_479 = happyReduce 4# 163# happyReduction_479-happyReduction_479 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Then) -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 KW_Group) -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 KW_By) -> -	case happyOut139 happy_x_4 of { happy_var_4 -> -	happyIn174-		 (GroupBy      (nIS happy_var_1 <++> ann happy_var_4 <** [happy_var_1,happy_var_2,happy_var_3]) happy_var_4-	) `HappyStk` happyRest}}}}--happyReduce_480 = happyReduce 4# 163# happyReduction_480-happyReduction_480 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Then) -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 KW_Group) -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 KW_Using) -> -	case happyOut139 happy_x_4 of { happy_var_4 -> -	happyIn174-		 (GroupUsing   (nIS happy_var_1 <++> ann happy_var_4 <** [happy_var_1,happy_var_2,happy_var_3]) happy_var_4-	) `HappyStk` happyRest}}}}--happyReduce_481 = happyReduce 6# 163# happyReduction_481-happyReduction_481 (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 { (Loc happy_var_1 KW_Then) -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 KW_Group) -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 KW_By) -> -	case happyOut139 happy_x_4 of { happy_var_4 -> -	case happyOutTok happy_x_5 of { (Loc happy_var_5 KW_Using) -> -	case happyOut139 happy_x_6 of { happy_var_6 -> -	happyIn174-		 (GroupByUsing (nIS happy_var_1 <++> ann happy_var_6 <** [happy_var_1,happy_var_2,happy_var_3,happy_var_5]) happy_var_4 happy_var_6-	) `HappyStk` happyRest}}}}}}--happyReduce_482 = happySpecReduce_3  164# happyReduction_482-happyReduction_482 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut175 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> -	case happyOut176 happy_x_3 of { happy_var_3 -> -	happyIn175-		 (let (sts, ss) = happy_var_1 in (happy_var_3 : sts, happy_var_2 : ss)-	)}}}--happyReduce_483 = happySpecReduce_1  164# happyReduction_483-happyReduction_483 happy_x_1-	 =  case happyOut176 happy_x_1 of { happy_var_1 -> -	happyIn175-		 (([happy_var_1],[])-	)}--happyReduce_484 = happySpecReduce_3  165# happyReduction_484-happyReduction_484 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut184 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftArrow) -> -	case happyOut139 happy_x_3 of { happy_var_3 -> -	happyIn176-		 (Generator (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3-	)}}}--happyReduce_485 = happySpecReduce_1  165# happyReduction_485-happyReduction_485 happy_x_1-	 =  case happyOut139 happy_x_1 of { happy_var_1 -> -	happyIn176-		 (Qualifier (ann happy_var_1) happy_var_1-	)}--happyReduce_486 = happySpecReduce_2  165# happyReduction_486-happyReduction_486 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Let) -> -	case happyOut61 happy_x_2 of { happy_var_2 -> -	happyIn176-		 (LetStmt   (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2-	)}}--happyReduce_487 = happySpecReduce_3  166# happyReduction_487-happyReduction_487 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftCurly) -> -	case happyOut178 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightCurly) -> -	happyIn177-		 ((fst happy_var_2, happy_var_1 <^^> happy_var_3, happy_var_1:snd happy_var_2 ++ [happy_var_3])-	)}}}--happyReduce_488 = happySpecReduce_3  166# happyReduction_488-happyReduction_488 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut224 happy_x_1 of { happy_var_1 -> -	case happyOut178 happy_x_2 of { happy_var_2 -> -	case happyOut225 happy_x_3 of { happy_var_3 -> -	happyIn177-		 ((fst happy_var_2, happy_var_1 <^^> happy_var_3, happy_var_1:snd happy_var_2 ++ [happy_var_3])-	)}}}--happyReduce_489 = happySpecReduce_3  167# happyReduction_489-happyReduction_489 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut25 happy_x_1 of { happy_var_1 -> -	case happyOut179 happy_x_2 of { happy_var_2 -> -	case happyOut25 happy_x_3 of { happy_var_3 -> -	happyIn178-		 ((reverse $ fst happy_var_2, happy_var_1 ++ snd happy_var_2 ++ happy_var_3)-	)}}}--happyReduce_490 = happySpecReduce_3  168# happyReduction_490-happyReduction_490 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut179 happy_x_1 of { happy_var_1 -> -	case happyOut24 happy_x_2 of { happy_var_2 -> -	case happyOut180 happy_x_3 of { happy_var_3 -> -	happyIn179-		 ((happy_var_3 : fst happy_var_1, snd happy_var_1 ++ happy_var_2)-	)}}}--happyReduce_491 = happySpecReduce_1  168# happyReduction_491-happyReduction_491 happy_x_1-	 =  case happyOut180 happy_x_1 of { happy_var_1 -> -	happyIn179-		 (([happy_var_1],[])-	)}--happyReduce_492 = happySpecReduce_3  169# happyReduction_492-happyReduction_492 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut184 happy_x_1 of { happy_var_1 -> -	case happyOut181 happy_x_2 of { happy_var_2 -> -	case happyOut134 happy_x_3 of { happy_var_3 -> -	happyIn180-		 (Alt (happy_var_1 <> happy_var_2 <+?> (fmap ann) (fst happy_var_3) <** snd happy_var_3) happy_var_1 happy_var_2 (fst happy_var_3)-	)}}}--happyReduce_493 = happySpecReduce_2  170# happyReduction_493-happyReduction_493 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 RightArrow) -> -	case happyOut139 happy_x_2 of { happy_var_2 -> -	happyIn181-		 (UnGuardedAlt (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2-	)}}--happyReduce_494 = happySpecReduce_1  170# happyReduction_494-happyReduction_494 happy_x_1-	 =  case happyOut182 happy_x_1 of { happy_var_1 -> -	happyIn181-		 (GuardedAlts  (snd happy_var_1) (reverse $ fst happy_var_1)-	)}--happyReduce_495 = happySpecReduce_2  171# happyReduction_495-happyReduction_495 happy_x_2-	happy_x_1-	 =  case happyOut182 happy_x_1 of { happy_var_1 -> -	case happyOut183 happy_x_2 of { happy_var_2 -> -	happyIn182-		 ((happy_var_2 : fst happy_var_1, snd happy_var_1 <++> ann happy_var_2)-	)}}--happyReduce_496 = happySpecReduce_1  171# happyReduction_496-happyReduction_496 happy_x_1-	 =  case happyOut183 happy_x_1 of { happy_var_1 -> -	happyIn182-		 (([happy_var_1], ann happy_var_1)-	)}--happyReduce_497 = happyMonadReduce 4# 172# happyReduction_497-happyReduction_497 (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 { (Loc happy_var_1 Bar) -> -	case happyOut175 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightArrow) -> -	case happyOut139 happy_x_4 of { happy_var_4 -> -	( do { checkPatternGuards (fst happy_var_2);-                                       let {l = nIS happy_var_1 <++> ann happy_var_4 <** (happy_var_1:snd happy_var_2 ++ [happy_var_3])};-                                       return (GuardedAlt l (reverse (fst happy_var_2)) happy_var_4) })}}}}-	) (\r -> happyReturn (happyIn183 r))--happyReduce_498 = happyMonadReduce 1# 173# happyReduction_498-happyReduction_498 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut140 happy_x_1 of { happy_var_1 -> -	( checkPattern happy_var_1)}-	) (\r -> happyReturn (happyIn184 r))--happyReduce_499 = happyMonadReduce 2# 173# happyReduction_499-happyReduction_499 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 Exclamation) -> -	case happyOut152 happy_x_2 of { happy_var_2 -> -	( checkPattern (BangPat (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2))}}-	) (\r -> happyReturn (happyIn184 r))--happyReduce_500 = happySpecReduce_3  174# happyReduction_500-happyReduction_500 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftCurly) -> -	case happyOut186 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightCurly) -> -	happyIn185-		 ((fst happy_var_2, happy_var_1 <^^> happy_var_3, happy_var_1:snd happy_var_2 ++ [happy_var_3])-	)}}}--happyReduce_501 = happySpecReduce_3  174# happyReduction_501-happyReduction_501 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut224 happy_x_1 of { happy_var_1 -> -	case happyOut186 happy_x_2 of { happy_var_2 -> -	case happyOut225 happy_x_3 of { happy_var_3 -> -	happyIn185-		 ((fst happy_var_2, happy_var_1 <^^> happy_var_3, happy_var_1:snd happy_var_2 ++ [happy_var_3])-	)}}}--happyReduce_502 = happySpecReduce_2  175# happyReduction_502-happyReduction_502 happy_x_2-	happy_x_1-	 =  case happyOut188 happy_x_1 of { happy_var_1 -> -	case happyOut187 happy_x_2 of { happy_var_2 -> -	happyIn186-		 ((happy_var_1 : fst happy_var_2, snd happy_var_2)-	)}}--happyReduce_503 = happySpecReduce_2  175# happyReduction_503-happyReduction_503 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 SemiColon) -> -	case happyOut186 happy_x_2 of { happy_var_2 -> -	happyIn186-		 ((fst happy_var_2, happy_var_1 : snd happy_var_2)-	)}}--happyReduce_504 = happySpecReduce_0  175# happyReduction_504-happyReduction_504  =  happyIn186-		 (([],[])-	)--happyReduce_505 = happySpecReduce_2  176# happyReduction_505-happyReduction_505 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 SemiColon) -> -	case happyOut186 happy_x_2 of { happy_var_2 -> -	happyIn187-		 ((fst happy_var_2, happy_var_1 : snd happy_var_2)-	)}}--happyReduce_506 = happySpecReduce_0  176# happyReduction_506-happyReduction_506  =  happyIn187-		 (([],[])-	)--happyReduce_507 = happySpecReduce_2  177# happyReduction_507-happyReduction_507 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Let) -> -	case happyOut61 happy_x_2 of { happy_var_2 -> -	happyIn188-		 (LetStmt (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2-	)}}--happyReduce_508 = happySpecReduce_3  177# happyReduction_508-happyReduction_508 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut184 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftArrow) -> -	case happyOut139 happy_x_3 of { happy_var_3 -> -	happyIn188-		 (Generator (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3-	)}}}--happyReduce_509 = happySpecReduce_1  177# happyReduction_509-happyReduction_509 happy_x_1-	 =  case happyOut139 happy_x_1 of { happy_var_1 -> -	happyIn188-		 (Qualifier (ann happy_var_1) happy_var_1-	)}--happyReduce_510 = happySpecReduce_2  177# happyReduction_510-happyReduction_510 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Rec) -> -	case happyOut185 happy_x_2 of { happy_var_2 -> -	happyIn188-		 (let (stms,inf,ss) = happy_var_2 in RecStmt (nIS happy_var_1 <++> inf <** happy_var_1:ss) stms-	)}}--happyReduce_511 = happySpecReduce_3  178# happyReduction_511-happyReduction_511 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut189 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> -	case happyOut190 happy_x_3 of { happy_var_3 -> -	happyIn189-		 (let (fbs, ss) = happy_var_1 in (happy_var_3 : fbs, happy_var_2 : ss)-	)}}}--happyReduce_512 = happySpecReduce_1  178# happyReduction_512-happyReduction_512 happy_x_1-	 =  case happyOut190 happy_x_1 of { happy_var_1 -> -	happyIn189-		 (([happy_var_1],[])-	)}--happyReduce_513 = happySpecReduce_3  179# happyReduction_513-happyReduction_513 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut197 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 Equals) -> -	case happyOut140 happy_x_3 of { happy_var_3 -> -	happyIn190-		 (FieldUpdate (happy_var_1 <>happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3-	)}}}--happyReduce_514 = happyMonadReduce 1# 179# happyReduction_514-happyReduction_514 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOut197 happy_x_1 of { happy_var_1 -> -	( checkEnabled NamedFieldPuns >> checkUnQual happy_var_1 >>= return . FieldPun (ann happy_var_1))}-	) (\r -> happyReturn (happyIn190 r))--happyReduce_515 = happyMonadReduce 1# 179# happyReduction_515-happyReduction_515 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 DotDot) -> -	( checkEnabled RecordWildCards >> return (FieldWildcard (nIS happy_var_1)))}-	) (\r -> happyReturn (happyIn190 r))--happyReduce_516 = happySpecReduce_3  180# happyReduction_516-happyReduction_516 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut25 happy_x_1 of { happy_var_1 -> -	case happyOut192 happy_x_2 of { happy_var_2 -> -	case happyOut25 happy_x_3 of { happy_var_3 -> -	happyIn191-		 ((reverse (fst happy_var_2), reverse happy_var_1 ++ snd happy_var_2 ++ reverse happy_var_3)-	)}}}--happyReduce_517 = happySpecReduce_3  181# happyReduction_517-happyReduction_517 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut192 happy_x_1 of { happy_var_1 -> -	case happyOut24 happy_x_2 of { happy_var_2 -> -	case happyOut193 happy_x_3 of { happy_var_3 -> -	happyIn192-		 ((happy_var_3 : fst happy_var_1, snd happy_var_1 ++ reverse happy_var_2)-	)}}}--happyReduce_518 = happySpecReduce_1  181# happyReduction_518-happyReduction_518 happy_x_1-	 =  case happyOut193 happy_x_1 of { happy_var_1 -> -	happyIn192-		 (([happy_var_1],[])-	)}--happyReduce_519 = happySpecReduce_3  182# happyReduction_519-happyReduction_519 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut198 happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 Equals) -> -	case happyOut139 happy_x_3 of { happy_var_3 -> -	happyIn193-		 (IPBind (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3-	)}}}--happyReduce_520 = happySpecReduce_2  183# happyReduction_520-happyReduction_520 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 RightParen) -> -	happyIn194-		 (p_unit_con              (happy_var_1 <^^> happy_var_2 <** [happy_var_1,happy_var_2])-	)}}--happyReduce_521 = happySpecReduce_2  183# happyReduction_521-happyReduction_521 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftSquare) -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 RightSquare) -> -	happyIn194-		 (List                    (happy_var_1 <^^> happy_var_2 <** [happy_var_1,happy_var_2]) []-	)}}--happyReduce_522 = happySpecReduce_3  183# happyReduction_522-happyReduction_522 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> -	case happyOut155 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> -	happyIn194-		 (p_tuple_con             (happy_var_1 <^^> happy_var_3 <** happy_var_1:reverse (happy_var_3:happy_var_2)) Boxed (length happy_var_2)-	)}}}--happyReduce_523 = happySpecReduce_2  183# happyReduction_523-happyReduction_523 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftHashParen) -> -	case happyOutTok happy_x_2 of { (Loc happy_var_2 RightHashParen) -> -	happyIn194-		 (p_unboxed_singleton_con (happy_var_1 <^^> happy_var_2 <** [happy_var_1,happy_var_2])-	)}}--happyReduce_524 = happySpecReduce_3  183# happyReduction_524-happyReduction_524 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftHashParen) -> -	case happyOut155 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightHashParen) -> -	happyIn194-		 (p_tuple_con             (happy_var_1 <^^> happy_var_3 <** happy_var_1:reverse (happy_var_3:happy_var_2)) Unboxed (length happy_var_2)-	)}}}--happyReduce_525 = happySpecReduce_1  183# happyReduction_525-happyReduction_525 happy_x_1-	 =  case happyOut200 happy_x_1 of { happy_var_1 -> -	happyIn194-		 (Con (ann happy_var_1) happy_var_1-	)}--happyReduce_526 = happySpecReduce_1  184# happyReduction_526-happyReduction_526 happy_x_1-	 =  case happyOut212 happy_x_1 of { happy_var_1 -> -	happyIn195-		 (happy_var_1-	)}--happyReduce_527 = happySpecReduce_3  184# happyReduction_527-happyReduction_527 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> -	case happyOut220 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> -	happyIn195-		 (fmap (const (happy_var_1 <^^> happy_var_3 <** [happy_var_1, srcInfoSpan (ann happy_var_2), happy_var_3])) happy_var_2-	)}}}--happyReduce_528 = happySpecReduce_1  185# happyReduction_528-happyReduction_528 happy_x_1-	 =  case happyOut211 happy_x_1 of { happy_var_1 -> -	happyIn196-		 (happy_var_1-	)}--happyReduce_529 = happySpecReduce_3  185# happyReduction_529-happyReduction_529 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> -	case happyOut220 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> -	happyIn196-		 (fmap (const (happy_var_1 <^^> happy_var_3 <** [happy_var_1, srcInfoSpan (ann happy_var_2), happy_var_3])) happy_var_2-	)}}}--happyReduce_530 = happySpecReduce_1  186# happyReduction_530-happyReduction_530 happy_x_1-	 =  case happyOut210 happy_x_1 of { happy_var_1 -> -	happyIn197-		 (happy_var_1-	)}--happyReduce_531 = happySpecReduce_3  186# happyReduction_531-happyReduction_531 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> -	case happyOut218 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> -	happyIn197-		 (fmap (const (happy_var_1 <^^> happy_var_3 <** [happy_var_1, srcInfoSpan (ann happy_var_2), happy_var_3])) happy_var_2-	)}}}--happyReduce_532 = happySpecReduce_1  187# happyReduction_532-happyReduction_532 happy_x_1-	 =  case happyOut213 happy_x_1 of { happy_var_1 -> -	happyIn198-		 (happy_var_1-	)}--happyReduce_533 = happySpecReduce_1  188# happyReduction_533-happyReduction_533 happy_x_1-	 =  case happyOut215 happy_x_1 of { happy_var_1 -> -	happyIn199-		 (happy_var_1-	)}--happyReduce_534 = happySpecReduce_3  188# happyReduction_534-happyReduction_534 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> -	case happyOut217 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> -	happyIn199-		 (fmap (const (happy_var_1 <^^> happy_var_3 <** [happy_var_1, srcInfoSpan (ann happy_var_2), happy_var_3])) happy_var_2-	)}}}--happyReduce_535 = happySpecReduce_1  189# happyReduction_535-happyReduction_535 happy_x_1-	 =  case happyOut214 happy_x_1 of { happy_var_1 -> -	happyIn200-		 (happy_var_1-	)}--happyReduce_536 = happySpecReduce_3  189# happyReduction_536-happyReduction_536 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> -	case happyOut209 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> -	happyIn200-		 (fmap (const (happy_var_1 <^^> happy_var_3 <** [happy_var_1, srcInfoSpan (ann happy_var_2), happy_var_3])) happy_var_2-	)}}}--happyReduce_537 = happySpecReduce_1  190# happyReduction_537-happyReduction_537 happy_x_1-	 =  case happyOut220 happy_x_1 of { happy_var_1 -> -	happyIn201-		 (happy_var_1-	)}--happyReduce_538 = happySpecReduce_3  190# happyReduction_538-happyReduction_538 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 BackQuote) -> -	case happyOut212 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 BackQuote) -> -	happyIn201-		 (fmap (const (happy_var_1 <^^> happy_var_3 <** [happy_var_1, srcInfoSpan (ann happy_var_2), happy_var_3])) happy_var_2-	)}}}--happyReduce_539 = happySpecReduce_1  191# happyReduction_539-happyReduction_539 happy_x_1-	 =  case happyOut218 happy_x_1 of { happy_var_1 -> -	happyIn202-		 (happy_var_1-	)}--happyReduce_540 = happySpecReduce_3  191# happyReduction_540-happyReduction_540 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 BackQuote) -> -	case happyOut210 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 BackQuote) -> -	happyIn202-		 (fmap (const (happy_var_1 <^^> happy_var_3 <** [happy_var_1, srcInfoSpan (ann happy_var_2), happy_var_3])) happy_var_2-	)}}}--happyReduce_541 = happySpecReduce_1  192# happyReduction_541-happyReduction_541 happy_x_1-	 =  case happyOut219 happy_x_1 of { happy_var_1 -> -	happyIn203-		 (happy_var_1-	)}--happyReduce_542 = happySpecReduce_3  192# happyReduction_542-happyReduction_542 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 BackQuote) -> -	case happyOut210 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 BackQuote) -> -	happyIn203-		 (fmap (const (happy_var_1 <^^> happy_var_3 <** [happy_var_1, srcInfoSpan (ann happy_var_2), happy_var_3])) happy_var_2-	)}}}--happyReduce_543 = happySpecReduce_1  193# happyReduction_543-happyReduction_543 happy_x_1-	 =  case happyOut217 happy_x_1 of { happy_var_1 -> -	happyIn204-		 (happy_var_1-	)}--happyReduce_544 = happySpecReduce_3  193# happyReduction_544-happyReduction_544 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 BackQuote) -> -	case happyOut215 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 BackQuote) -> -	happyIn204-		 (fmap (const (happy_var_1 <^^> happy_var_3 <** [happy_var_1, srcInfoSpan (ann happy_var_2), happy_var_3])) happy_var_2-	)}}}--happyReduce_545 = happySpecReduce_1  194# happyReduction_545-happyReduction_545 happy_x_1-	 =  case happyOut209 happy_x_1 of { happy_var_1 -> -	happyIn205-		 (happy_var_1-	)}--happyReduce_546 = happySpecReduce_3  194# happyReduction_546-happyReduction_546 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 BackQuote) -> -	case happyOut214 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 BackQuote) -> -	happyIn205-		 (fmap (const (happy_var_1 <^^> happy_var_3 <** [happy_var_1, srcInfoSpan (ann happy_var_2), happy_var_3])) happy_var_2-	)}}}--happyReduce_547 = happySpecReduce_1  195# happyReduction_547-happyReduction_547 happy_x_1-	 =  case happyOut201 happy_x_1 of { happy_var_1 -> -	happyIn206-		 (VarOp (ann happy_var_1) happy_var_1-	)}--happyReduce_548 = happySpecReduce_1  195# happyReduction_548-happyReduction_548 happy_x_1-	 =  case happyOut204 happy_x_1 of { happy_var_1 -> -	happyIn206-		 (ConOp (ann happy_var_1) happy_var_1-	)}--happyReduce_549 = happySpecReduce_1  196# happyReduction_549-happyReduction_549 happy_x_1-	 =  case happyOut202 happy_x_1 of { happy_var_1 -> -	happyIn207-		 (QVarOp (ann happy_var_1) happy_var_1-	)}--happyReduce_550 = happySpecReduce_1  196# happyReduction_550-happyReduction_550 happy_x_1-	 =  case happyOut205 happy_x_1 of { happy_var_1 -> -	happyIn207-		 (QConOp (ann happy_var_1) happy_var_1-	)}--happyReduce_551 = happySpecReduce_1  197# happyReduction_551-happyReduction_551 happy_x_1-	 =  case happyOut203 happy_x_1 of { happy_var_1 -> -	happyIn208-		 (QVarOp (ann happy_var_1) happy_var_1-	)}--happyReduce_552 = happySpecReduce_1  197# happyReduction_552-happyReduction_552 happy_x_1-	 =  case happyOut205 happy_x_1 of { happy_var_1 -> -	happyIn208-		 (QConOp (ann happy_var_1) happy_var_1-	)}--happyReduce_553 = happySpecReduce_1  198# happyReduction_553-happyReduction_553 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Colon) -> -	happyIn209-		 (list_cons_name (nIS happy_var_1)-	)}--happyReduce_554 = happySpecReduce_1  198# happyReduction_554-happyReduction_554 happy_x_1-	 =  case happyOut216 happy_x_1 of { happy_var_1 -> -	happyIn209-		 (happy_var_1-	)}--happyReduce_555 = happySpecReduce_1  199# happyReduction_555-happyReduction_555 happy_x_1-	 =  case happyOut212 happy_x_1 of { happy_var_1 -> -	happyIn210-		 (UnQual (ann happy_var_1) happy_var_1-	)}--happyReduce_556 = happySpecReduce_1  199# happyReduction_556-happyReduction_556 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn210-		 (let {Loc l (QVarId q) = happy_var_1; nis = nIS l}-                                 in Qual nis (ModuleName nis (fst q)) (Ident nis (snd q))-	)}--happyReduce_557 = happySpecReduce_1  200# happyReduction_557-happyReduction_557 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn211-		 (let Loc l (VarId v) = happy_var_1 in Ident (nIS l) v-	)}--happyReduce_558 = happySpecReduce_1  200# happyReduction_558-happyReduction_558 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_As) -> -	happyIn211-		 (as_name        (nIS happy_var_1)-	)}--happyReduce_559 = happySpecReduce_1  200# happyReduction_559-happyReduction_559 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Qualified) -> -	happyIn211-		 (qualified_name (nIS happy_var_1)-	)}--happyReduce_560 = happySpecReduce_1  200# happyReduction_560-happyReduction_560 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Hiding) -> -	happyIn211-		 (hiding_name    (nIS happy_var_1)-	)}--happyReduce_561 = happySpecReduce_1  200# happyReduction_561-happyReduction_561 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Export) -> -	happyIn211-		 (export_name    (nIS happy_var_1)-	)}--happyReduce_562 = happySpecReduce_1  200# happyReduction_562-happyReduction_562 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_StdCall) -> -	happyIn211-		 (stdcall_name   (nIS happy_var_1)-	)}--happyReduce_563 = happySpecReduce_1  200# happyReduction_563-happyReduction_563 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_CCall) -> -	happyIn211-		 (ccall_name     (nIS happy_var_1)-	)}--happyReduce_564 = happySpecReduce_1  200# happyReduction_564-happyReduction_564 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_CPlusPlus) -> -	happyIn211-		 (cplusplus_name (nIS happy_var_1)-	)}--happyReduce_565 = happySpecReduce_1  200# happyReduction_565-happyReduction_565 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_DotNet) -> -	happyIn211-		 (dotnet_name    (nIS happy_var_1)-	)}--happyReduce_566 = happySpecReduce_1  200# happyReduction_566-happyReduction_566 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Jvm) -> -	happyIn211-		 (jvm_name       (nIS happy_var_1)-	)}--happyReduce_567 = happySpecReduce_1  200# happyReduction_567-happyReduction_567 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Js) -> -	happyIn211-		 (js_name        (nIS happy_var_1)-	)}--happyReduce_568 = happySpecReduce_1  201# happyReduction_568-happyReduction_568 happy_x_1-	 =  case happyOut211 happy_x_1 of { happy_var_1 -> -	happyIn212-		 (happy_var_1-	)}--happyReduce_569 = happySpecReduce_1  201# happyReduction_569-happyReduction_569 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Safe) -> -	happyIn212-		 (safe_name       (nIS happy_var_1)-	)}--happyReduce_570 = happySpecReduce_1  201# happyReduction_570-happyReduction_570 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Unsafe) -> -	happyIn212-		 (unsafe_name     (nIS happy_var_1)-	)}--happyReduce_571 = happySpecReduce_1  201# happyReduction_571-happyReduction_571 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Threadsafe) -> -	happyIn212-		 (threadsafe_name (nIS happy_var_1)-	)}--happyReduce_572 = happySpecReduce_1  201# happyReduction_572-happyReduction_572 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Forall) -> -	happyIn212-		 (forall_name	  (nIS happy_var_1)-	)}--happyReduce_573 = happySpecReduce_1  201# happyReduction_573-happyReduction_573 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Family) -> -	happyIn212-		 (family_name     (nIS happy_var_1)-	)}--happyReduce_574 = happySpecReduce_1  202# happyReduction_574-happyReduction_574 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn213-		 (let Loc l (IDupVarId i) = happy_var_1 in IPDup (nIS l) i-	)}--happyReduce_575 = happySpecReduce_1  202# happyReduction_575-happyReduction_575 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn213-		 (let Loc l (ILinVarId i) = happy_var_1 in IPLin (nIS l) i-	)}--happyReduce_576 = happySpecReduce_1  203# happyReduction_576-happyReduction_576 happy_x_1-	 =  case happyOut215 happy_x_1 of { happy_var_1 -> -	happyIn214-		 (UnQual (ann happy_var_1) happy_var_1-	)}--happyReduce_577 = happySpecReduce_1  203# happyReduction_577-happyReduction_577 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn214-		 (let {Loc l (QConId q) = happy_var_1; nis = nIS l} in Qual nis (ModuleName nis (fst q)) (Ident nis (snd q))-	)}--happyReduce_578 = happySpecReduce_1  204# happyReduction_578-happyReduction_578 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn215-		 (let Loc l (ConId c) = happy_var_1 in Ident (nIS l) c-	)}--happyReduce_579 = happySpecReduce_1  205# happyReduction_579-happyReduction_579 happy_x_1-	 =  case happyOut217 happy_x_1 of { happy_var_1 -> -	happyIn216-		 (UnQual (ann happy_var_1) happy_var_1-	)}--happyReduce_580 = happySpecReduce_1  205# happyReduction_580-happyReduction_580 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn216-		 (let {Loc l (QConSym q) = happy_var_1; nis = nIS l} in Qual nis (ModuleName nis (fst q)) (Symbol nis (snd q))-	)}--happyReduce_581 = happySpecReduce_1  206# happyReduction_581-happyReduction_581 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn217-		 (let Loc l (ConSym c) = happy_var_1 in Symbol (nIS l) c-	)}--happyReduce_582 = happySpecReduce_1  207# happyReduction_582-happyReduction_582 happy_x_1-	 =  case happyOut220 happy_x_1 of { happy_var_1 -> -	happyIn218-		 (UnQual (ann happy_var_1) happy_var_1-	)}--happyReduce_583 = happySpecReduce_1  207# happyReduction_583-happyReduction_583 happy_x_1-	 =  case happyOut222 happy_x_1 of { happy_var_1 -> -	happyIn218-		 (happy_var_1-	)}--happyReduce_584 = happySpecReduce_1  208# happyReduction_584-happyReduction_584 happy_x_1-	 =  case happyOut221 happy_x_1 of { happy_var_1 -> -	happyIn219-		 (UnQual (ann happy_var_1) happy_var_1-	)}--happyReduce_585 = happySpecReduce_1  208# happyReduction_585-happyReduction_585 happy_x_1-	 =  case happyOut222 happy_x_1 of { happy_var_1 -> -	happyIn219-		 (happy_var_1-	)}--happyReduce_586 = happySpecReduce_1  209# happyReduction_586-happyReduction_586 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn220-		 (let Loc l (VarSym v) = happy_var_1 in Symbol (nIS l) v-	)}--happyReduce_587 = happySpecReduce_1  209# happyReduction_587-happyReduction_587 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Minus) -> -	happyIn220-		 (minus_name (nIS happy_var_1)-	)}--happyReduce_588 = happySpecReduce_1  209# happyReduction_588-happyReduction_588 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Exclamation) -> -	happyIn220-		 (bang_name  (nIS happy_var_1)-	)}--happyReduce_589 = happySpecReduce_1  209# happyReduction_589-happyReduction_589 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Dot) -> -	happyIn220-		 (dot_name   (nIS happy_var_1)-	)}--happyReduce_590 = happySpecReduce_1  209# happyReduction_590-happyReduction_590 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Star) -> -	happyIn220-		 (star_name  (nIS happy_var_1)-	)}--happyReduce_591 = happySpecReduce_1  210# happyReduction_591-happyReduction_591 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn221-		 (let Loc l (VarSym v) = happy_var_1 in Symbol (nIS l) v-	)}--happyReduce_592 = happySpecReduce_1  210# happyReduction_592-happyReduction_592 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Exclamation) -> -	happyIn221-		 (bang_name (nIS happy_var_1)-	)}--happyReduce_593 = happySpecReduce_1  210# happyReduction_593-happyReduction_593 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Dot) -> -	happyIn221-		 (dot_name  (nIS happy_var_1)-	)}--happyReduce_594 = happySpecReduce_1  210# happyReduction_594-happyReduction_594 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Star) -> -	happyIn221-		 (star_name (nIS happy_var_1)-	)}--happyReduce_595 = happySpecReduce_1  211# happyReduction_595-happyReduction_595 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn222-		 (let {Loc l (QVarSym q) = happy_var_1; nis = nIS l} in Qual nis (ModuleName nis (fst q)) (Symbol nis (snd q))-	)}--happyReduce_596 = happySpecReduce_1  212# happyReduction_596-happyReduction_596 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn223-		 (let Loc l (IntTok        (i,raw)) = happy_var_1 in Int        (nIS l) i raw-	)}--happyReduce_597 = happySpecReduce_1  212# happyReduction_597-happyReduction_597 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn223-		 (let Loc l (Character     (c,raw)) = happy_var_1 in Char       (nIS l) c raw-	)}--happyReduce_598 = happySpecReduce_1  212# happyReduction_598-happyReduction_598 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn223-		 (let Loc l (FloatTok      (r,raw)) = happy_var_1 in Frac       (nIS l) r raw-	)}--happyReduce_599 = happySpecReduce_1  212# happyReduction_599-happyReduction_599 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn223-		 (let Loc l (StringTok     (s,raw)) = happy_var_1 in String     (nIS l) s raw-	)}--happyReduce_600 = happySpecReduce_1  212# happyReduction_600-happyReduction_600 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn223-		 (let Loc l (IntTokHash    (i,raw)) = happy_var_1 in PrimInt    (nIS l) i raw-	)}--happyReduce_601 = happySpecReduce_1  212# happyReduction_601-happyReduction_601 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn223-		 (let Loc l (WordTokHash   (w,raw)) = happy_var_1 in PrimWord   (nIS l) w raw-	)}--happyReduce_602 = happySpecReduce_1  212# happyReduction_602-happyReduction_602 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn223-		 (let Loc l (FloatTokHash  (f,raw)) = happy_var_1 in PrimFloat  (nIS l) f raw-	)}--happyReduce_603 = happySpecReduce_1  212# happyReduction_603-happyReduction_603 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn223-		 (let Loc l (DoubleTokHash (d,raw)) = happy_var_1 in PrimDouble (nIS l) d raw-	)}--happyReduce_604 = happySpecReduce_1  212# happyReduction_604-happyReduction_604 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn223-		 (let Loc l (CharacterHash (c,raw)) = happy_var_1 in PrimChar   (nIS l) c raw-	)}--happyReduce_605 = happySpecReduce_1  212# happyReduction_605-happyReduction_605 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn223-		 (let Loc l (StringHash    (s,raw)) = happy_var_1 in PrimString (nIS l) s raw-	)}--happyReduce_606 = happyMonadReduce 0# 213# happyReduction_606-happyReduction_606 (happyRest) tk-	 = happyThen (( pushCurrentContext >> getSrcLoc >>= \s -> return $ mkSrcSpan s s {- >>= \x -> trace (show x) (return x) -})-	) (\r -> happyReturn (happyIn224 r))--happyReduce_607 = happySpecReduce_1  214# happyReduction_607-happyReduction_607 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 VRightCurly) -> -	happyIn225-		 (happy_var_1 {- >>= \x -> trace (show x ++ show x ++ show x) (return x) -}-	)}--happyReduce_608 = happyMonadReduce 1# 214# happyReduction_608-happyReduction_608 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen (( popContext >> getSrcLoc >>= \s -> return $ mkSrcSpan s s {- >>= \x -> trace (show x ++ show x) (return x) -})-	) (\r -> happyReturn (happyIn225 r))--happyReduce_609 = happySpecReduce_1  215# happyReduction_609-happyReduction_609 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn226-		 (let Loc l (ConId  n) = happy_var_1 in ModuleName (nIS l) n-	)}--happyReduce_610 = happySpecReduce_1  215# happyReduction_610-happyReduction_610 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn226-		 (let Loc l (QConId n) = happy_var_1 in ModuleName (nIS l) (fst n ++ '.':snd n)-	)}--happyReduce_611 = happySpecReduce_1  216# happyReduction_611-happyReduction_611 happy_x_1-	 =  case happyOut199 happy_x_1 of { happy_var_1 -> -	happyIn227-		 (happy_var_1-	)}--happyReduce_612 = happySpecReduce_1  217# happyReduction_612-happyReduction_612 happy_x_1-	 =  case happyOut200 happy_x_1 of { happy_var_1 -> -	happyIn228-		 (happy_var_1-	)}--happyReduce_613 = happySpecReduce_1  218# happyReduction_613-happyReduction_613 happy_x_1-	 =  case happyOut230 happy_x_1 of { happy_var_1 -> -	happyIn229-		 (happy_var_1-	)}--happyReduce_614 = happySpecReduce_1  219# happyReduction_614-happyReduction_614 happy_x_1-	 =  case happyOut211 happy_x_1 of { happy_var_1 -> -	happyIn230-		 (happy_var_1-	)}--happyReduce_615 = happySpecReduce_1  219# happyReduction_615-happyReduction_615 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Safe) -> -	happyIn230-		 (safe_name       (nIS happy_var_1)-	)}--happyReduce_616 = happySpecReduce_1  219# happyReduction_616-happyReduction_616 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Unsafe) -> -	happyIn230-		 (unsafe_name     (nIS happy_var_1)-	)}--happyReduce_617 = happySpecReduce_1  219# happyReduction_617-happyReduction_617 happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Threadsafe) -> -	happyIn230-		 (threadsafe_name (nIS happy_var_1)-	)}--happyReduce_618 = happySpecReduce_3  220# happyReduction_618-happyReduction_618 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 BackQuote) -> -	case happyOut229 happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { (Loc happy_var_3 BackQuote) -> -	happyIn231-		 (UnQual (happy_var_1 <^^> happy_var_3 <** [happy_var_1, srcInfoSpan (ann happy_var_2), happy_var_3]) happy_var_2-	)}}}--happyReduce_619 = happySpecReduce_1  220# happyReduction_619-happyReduction_619 happy_x_1-	 =  case happyOut232 happy_x_1 of { happy_var_1 -> -	happyIn231-		 (UnQual (ann happy_var_1) happy_var_1-	)}--happyReduce_620 = happySpecReduce_1  221# happyReduction_620-happyReduction_620 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn232-		 (let Loc l (VarSym x) = happy_var_1 in Symbol (nIS l) x-	)}--happyNewToken action sts stk-	= lexer(\tk -> -	let cont i = happyDoAction i tk action sts stk in-	case tk of {-	Loc _ EOF -> happyDoAction 138# tk action sts stk;-	Loc _ (VarId _) -> cont 1#;-	Loc _ (QVarId _) -> cont 2#;-	Loc _ (IDupVarId _) -> cont 3#;-	Loc _ (ILinVarId _) -> cont 4#;-	Loc _ (ConId _) -> cont 5#;-	Loc _ (QConId _) -> cont 6#;-	Loc _ (DVarId _) -> cont 7#;-	Loc _ (VarSym _) -> cont 8#;-	Loc _ (ConSym _) -> cont 9#;-	Loc _ (QVarSym _) -> cont 10#;-	Loc _ (QConSym _) -> cont 11#;-	Loc _ (IntTok _) -> cont 12#;-	Loc _ (FloatTok _) -> cont 13#;-	Loc _ (Character _) -> cont 14#;-	Loc _ (StringTok _) -> cont 15#;-	Loc _ (IntTokHash _) -> cont 16#;-	Loc _ (WordTokHash _) -> cont 17#;-	Loc _ (FloatTokHash _) -> cont 18#;-	Loc _ (DoubleTokHash _) -> cont 19#;-	Loc _ (CharacterHash _) -> cont 20#;-	Loc _ (StringHash _) -> cont 21#;-	Loc happy_dollar_dollar LeftParen -> cont 22#;-	Loc happy_dollar_dollar RightParen -> cont 23#;-	Loc happy_dollar_dollar LeftHashParen -> cont 24#;-	Loc happy_dollar_dollar RightHashParen -> cont 25#;-	Loc happy_dollar_dollar LeftCurlyBar -> cont 26#;-	Loc happy_dollar_dollar RightCurlyBar -> cont 27#;-	Loc happy_dollar_dollar SemiColon -> cont 28#;-	Loc happy_dollar_dollar LeftCurly -> cont 29#;-	Loc happy_dollar_dollar RightCurly -> cont 30#;-	Loc happy_dollar_dollar VRightCurly -> cont 31#;-	Loc happy_dollar_dollar LeftSquare -> cont 32#;-	Loc happy_dollar_dollar RightSquare -> cont 33#;-	Loc happy_dollar_dollar Comma -> cont 34#;-	Loc happy_dollar_dollar Underscore -> cont 35#;-	Loc happy_dollar_dollar BackQuote -> cont 36#;-	Loc happy_dollar_dollar Dot -> cont 37#;-	Loc happy_dollar_dollar DotDot -> cont 38#;-	Loc happy_dollar_dollar Colon -> cont 39#;-	Loc happy_dollar_dollar DoubleColon -> cont 40#;-	Loc happy_dollar_dollar Equals -> cont 41#;-	Loc happy_dollar_dollar Backslash -> cont 42#;-	Loc happy_dollar_dollar Bar -> cont 43#;-	Loc happy_dollar_dollar LeftArrow -> cont 44#;-	Loc happy_dollar_dollar RightArrow -> cont 45#;-	Loc happy_dollar_dollar At -> cont 46#;-	Loc happy_dollar_dollar Tilde -> cont 47#;-	Loc happy_dollar_dollar DoubleArrow -> cont 48#;-	Loc happy_dollar_dollar Minus -> cont 49#;-	Loc happy_dollar_dollar Exclamation -> cont 50#;-	Loc happy_dollar_dollar Star -> cont 51#;-	Loc happy_dollar_dollar LeftArrowTail -> cont 52#;-	Loc happy_dollar_dollar RightArrowTail -> cont 53#;-	Loc happy_dollar_dollar LeftDblArrowTail -> cont 54#;-	Loc happy_dollar_dollar RightDblArrowTail -> cont 55#;-	Loc happy_dollar_dollar RPGuardOpen -> cont 56#;-	Loc happy_dollar_dollar RPGuardClose -> cont 57#;-	Loc happy_dollar_dollar RPCAt -> cont 58#;-	Loc _ (THIdEscape _) -> cont 59#;-	Loc happy_dollar_dollar THParenEscape -> cont 60#;-	Loc happy_dollar_dollar THExpQuote -> cont 61#;-	Loc happy_dollar_dollar THPatQuote -> cont 62#;-	Loc happy_dollar_dollar THTypQuote -> cont 63#;-	Loc happy_dollar_dollar THDecQuote -> cont 64#;-	Loc happy_dollar_dollar THCloseQuote -> cont 65#;-	Loc happy_dollar_dollar THVarQuote -> cont 66#;-	Loc happy_dollar_dollar THTyQuote -> cont 67#;-	Loc _ (THQuasiQuote _) -> cont 68#;-	Loc _ (XPCDATA _) -> cont 69#;-	Loc happy_dollar_dollar XStdTagOpen -> cont 70#;-	Loc happy_dollar_dollar XCloseTagOpen -> cont 71#;-	Loc happy_dollar_dollar XCodeTagOpen -> cont 72#;-	Loc happy_dollar_dollar XChildTagOpen -> cont 73#;-	Loc happy_dollar_dollar XStdTagClose -> cont 74#;-	Loc happy_dollar_dollar XEmptyTagClose -> cont 75#;-	Loc happy_dollar_dollar XCodeTagClose -> cont 76#;-	Loc happy_dollar_dollar XRPatOpen -> cont 77#;-	Loc happy_dollar_dollar XRPatClose -> cont 78#;-	Loc happy_dollar_dollar KW_Foreign -> cont 79#;-	Loc happy_dollar_dollar KW_Export -> cont 80#;-	Loc happy_dollar_dollar KW_Safe -> cont 81#;-	Loc happy_dollar_dollar KW_Unsafe -> cont 82#;-	Loc happy_dollar_dollar KW_Threadsafe -> cont 83#;-	Loc happy_dollar_dollar KW_StdCall -> cont 84#;-	Loc happy_dollar_dollar KW_CCall -> cont 85#;-	Loc happy_dollar_dollar KW_CPlusPlus -> cont 86#;-	Loc happy_dollar_dollar KW_DotNet -> cont 87#;-	Loc happy_dollar_dollar KW_Jvm -> cont 88#;-	Loc happy_dollar_dollar KW_Js -> cont 89#;-	Loc happy_dollar_dollar KW_As -> cont 90#;-	Loc happy_dollar_dollar KW_By -> cont 91#;-	Loc happy_dollar_dollar KW_Case -> cont 92#;-	Loc happy_dollar_dollar KW_Class -> cont 93#;-	Loc happy_dollar_dollar KW_Data -> cont 94#;-	Loc happy_dollar_dollar KW_Default -> cont 95#;-	Loc happy_dollar_dollar KW_Deriving -> cont 96#;-	Loc happy_dollar_dollar KW_Do -> cont 97#;-	Loc happy_dollar_dollar KW_Else -> cont 98#;-	Loc happy_dollar_dollar KW_Family -> cont 99#;-	Loc happy_dollar_dollar KW_Forall -> cont 100#;-	Loc happy_dollar_dollar KW_Group -> cont 101#;-	Loc happy_dollar_dollar KW_Hiding -> cont 102#;-	Loc happy_dollar_dollar KW_If -> cont 103#;-	Loc happy_dollar_dollar KW_Import -> cont 104#;-	Loc happy_dollar_dollar KW_In -> cont 105#;-	Loc happy_dollar_dollar KW_Infix -> cont 106#;-	Loc happy_dollar_dollar KW_InfixL -> cont 107#;-	Loc happy_dollar_dollar KW_InfixR -> cont 108#;-	Loc happy_dollar_dollar KW_Instance -> cont 109#;-	Loc happy_dollar_dollar KW_Let -> cont 110#;-	Loc happy_dollar_dollar KW_MDo -> cont 111#;-	Loc happy_dollar_dollar KW_Module -> cont 112#;-	Loc happy_dollar_dollar KW_NewType -> cont 113#;-	Loc happy_dollar_dollar KW_Of -> cont 114#;-	Loc happy_dollar_dollar KW_Proc -> cont 115#;-	Loc happy_dollar_dollar KW_Rec -> cont 116#;-	Loc happy_dollar_dollar KW_Then -> cont 117#;-	Loc happy_dollar_dollar KW_Type -> cont 118#;-	Loc happy_dollar_dollar KW_Using -> cont 119#;-	Loc happy_dollar_dollar KW_Where -> cont 120#;-	Loc happy_dollar_dollar KW_Qualified -> cont 121#;-	Loc _ (INLINE _) -> cont 122#;-	Loc happy_dollar_dollar INLINE_CONLIKE -> cont 123#;-	Loc happy_dollar_dollar SPECIALISE -> cont 124#;-	Loc _ (SPECIALISE_INLINE _) -> cont 125#;-	Loc happy_dollar_dollar SOURCE -> cont 126#;-	Loc happy_dollar_dollar RULES -> cont 127#;-	Loc happy_dollar_dollar CORE -> cont 128#;-	Loc happy_dollar_dollar SCC -> cont 129#;-	Loc happy_dollar_dollar GENERATED -> cont 130#;-	Loc happy_dollar_dollar DEPRECATED -> cont 131#;-	Loc happy_dollar_dollar WARNING -> cont 132#;-	Loc happy_dollar_dollar UNPACK -> cont 133#;-	Loc _ (OPTIONS _) -> cont 134#;-	Loc happy_dollar_dollar LANGUAGE -> cont 135#;-	Loc happy_dollar_dollar ANN -> cont 136#;-	Loc happy_dollar_dollar PragmaEnd -> cont 137#;-	_ -> happyError' tk-	})--happyError_ tk = happyError' tk--happyThen :: () => P a -> (a -> P b) -> P b-happyThen = (>>=)-happyReturn :: () => a -> P a-happyReturn = (return)-happyThen1 = happyThen-happyReturn1 :: () => a -> P a-happyReturn1 = happyReturn-happyError' :: () => Loc Token -> P a-happyError' tk = parseError tk--mparseModule = happySomeParser where-  happySomeParser = happyThen (happyParse 0#) (\x -> happyReturn (happyOut13 x))--mparseExp = happySomeParser where-  happySomeParser = happyThen (happyParse 1#) (\x -> happyReturn (happyOut139 x))--mparsePat = happySomeParser where-  happySomeParser = happyThen (happyParse 2#) (\x -> happyReturn (happyOut184 x))--mparseDecl = happySomeParser where-  happySomeParser = happyThen (happyParse 3#) (\x -> happyReturn (happyOut50 x))--mparseType = happySomeParser where-  happySomeParser = happyThen (happyParse 4#) (\x -> happyReturn (happyOut88 x))--mparseStmt = happySomeParser where-  happySomeParser = happyThen (happyParse 5#) (\x -> happyReturn (happyOut188 x))--mparseModules = happySomeParser where-  happySomeParser = happyThen (happyParse 6#) (\x -> happyReturn (happyOut11 x))--mfindOptPragmas = happySomeParser where-  happySomeParser = happyThen (happyParse 7#) (\x -> happyReturn (happyOut15 x))--happySeq = happyDontSeq---type L = SrcSpanInfo -- just for convenience-type S = SrcSpan--parseError :: Loc Token -> P a-parseError t = fail $ "Parse error: " ++ showToken (unLoc t)--(<>) :: (Annotated a, Annotated b) => a SrcSpanInfo -> b SrcSpanInfo -> SrcSpanInfo-a <> b = ann a <++> ann b-infixl 6 <>--nIS = noInfoSpan-iS = infoSpan----- | Parse of a string, which should contain a complete Haskell module.-parseModule :: String -> ParseResult (Module SrcSpanInfo)-parseModule = simpleParse mparseModule---- | Parse of a string containing a complete Haskell module, using an explicit mode.-parseModuleWithMode :: ParseMode -> String -> ParseResult (Module SrcSpanInfo)-parseModuleWithMode = modeParse mparseModule---- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.-parseModuleWithComments :: ParseMode -> String -> ParseResult (Module SrcSpanInfo, [Comment])-parseModuleWithComments = commentParse mparseModule---- | Parse of a string containing a Haskell expression.-parseExp :: String -> ParseResult (Exp SrcSpanInfo)-parseExp = simpleParse mparseExp---- | Parse of a string containing a Haskell expression, using an explicit mode.-parseExpWithMode :: ParseMode -> String -> ParseResult (Exp SrcSpanInfo)-parseExpWithMode = modeParse mparseExp---- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.-parseExpWithComments :: ParseMode -> String -> ParseResult (Exp SrcSpanInfo, [Comment])-parseExpWithComments = commentParse mparseExp---- | Parse of a string containing a Haskell pattern.-parsePat :: String -> ParseResult (Pat SrcSpanInfo)-parsePat = simpleParse mparsePat---- | Parse of a string containing a Haskell pattern, using an explicit mode.-parsePatWithMode :: ParseMode -> String -> ParseResult (Pat SrcSpanInfo)-parsePatWithMode = modeParse mparsePat---- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.-parsePatWithComments :: ParseMode -> String -> ParseResult (Pat SrcSpanInfo, [Comment])-parsePatWithComments = commentParse mparsePat---- | Parse of a string containing a Haskell top-level declaration.-parseDecl :: String -> ParseResult (Decl SrcSpanInfo)-parseDecl = simpleParse mparseDecl---- | Parse of a string containing a Haskell top-level declaration, using an explicit mode.-parseDeclWithMode :: ParseMode -> String -> ParseResult (Decl SrcSpanInfo)-parseDeclWithMode = modeParse mparseDecl---- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.-parseDeclWithComments :: ParseMode -> String -> ParseResult (Decl SrcSpanInfo, [Comment])-parseDeclWithComments = commentParse mparseDecl---- | Parse of a string containing a Haskell type.-parseType :: String -> ParseResult (Type SrcSpanInfo)-parseType = runParser mparseType---- | Parse of a string containing a Haskell type, using an explicit mode.-parseTypeWithMode :: ParseMode -> String -> ParseResult (Type SrcSpanInfo)-parseTypeWithMode mode = runParserWithMode mode mparseType---- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.-parseTypeWithComments :: ParseMode -> String -> ParseResult (Type SrcSpanInfo, [Comment])-parseTypeWithComments mode str = runParserWithModeComments mode mparseType str---- | Parse of a string containing a Haskell statement.-parseStmt :: String -> ParseResult (Stmt SrcSpanInfo)-parseStmt = runParser mparseStmt---- | Parse of a string containing a Haskell type, using an explicit mode.-parseStmtWithMode :: ParseMode -> String -> ParseResult (Stmt SrcSpanInfo)-parseStmtWithMode mode = runParserWithMode mode mparseStmt---- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.-parseStmtWithComments :: ParseMode -> String -> ParseResult (Stmt SrcSpanInfo, [Comment])-parseStmtWithComments mode str = runParserWithModeComments mode mparseStmt str---simpleParse :: AppFixity a => P (a L) -> String -> ParseResult (a L)-simpleParse p = applyFixities preludeFixities <=< runParser p--modeParse :: AppFixity a => P (a L) -> ParseMode -> String -> ParseResult (a L)-modeParse p mode = applyFixities' (fixities mode) <=< runParserWithMode mode p--commentParse :: AppFixity a => P (a L) -> ParseMode -> String -> ParseResult (a L, [Comment])-commentParse p mode str = do (ast, cs) <- runParserWithModeComments mode p str-                             ast' <- applyFixities' (fixities mode) ast-                             return (ast', cs)---- | Partial parse of a string starting with a series of top-level option pragmas.-getTopPragmas :: String -> ParseResult [ModulePragma SrcSpanInfo]-getTopPragmas = runParser (mfindOptPragmas >>= \(ps,_,_) -> return ps)---- | Parse of a string, which should contain a complete Haskell module.-parseModules :: String -> ParseResult [Module SrcSpanInfo]-parseModules = mapM (applyFixities preludeFixities) <=< runParser mparseModules---- | Parse of a string containing a complete Haskell module, using an explicit mode.-parseModulesWithMode :: ParseMode -> String -> ParseResult [Module SrcSpanInfo]-parseModulesWithMode mode = mapM (applyFixities' (fixities mode)) <=< runParserWithMode mode mparseModules---- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.-parseModulesWithComments :: ParseMode -> String -> ParseResult ([Module SrcSpanInfo], [Comment])-parseModulesWithComments mode str = do (ast,cs) <- runParserWithModeComments mode mparseModules str-                                       ast' <- mapM (applyFixities' (fixities mode)) ast-                                       return (ast', cs)-applyFixities' :: (AppFixity a) => Maybe [Fixity] -> a L -> ParseResult (a L)-applyFixities' Nothing ast = return ast-applyFixities' (Just fixs) ast = applyFixities fixs ast-{-# 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 28 "templates/GenericTemplate.hs" #-}---data Happy_IntList = HappyCons Int# Happy_IntList------{-# LINE 49 "templates/GenericTemplate.hs" #-}--{-# LINE 59 "templates/GenericTemplate.hs" #-}--{-# LINE 68 "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 <# (0# :: Int#)) -> {- nothing -}--				     (happyReduceArr ! rule) i tk st-				     where rule = (I# ((negateInt# ((n +# (1# :: Int#))))))-		n		  -> {- nothing -}---				     happyShift new_state i tk st-				     where new_state = (n -# (1# :: Int#))-   where off    = indexShortOffAddr happyActOffsets st-	 off_i  = (off +# i)-	 check  = if (off_i >=# (0# :: Int#))-			then (indexShortOffAddr happyCheck off_i ==#  i)-			else False- 	 action | check     = indexShortOffAddr happyTable off_i-		| otherwise = indexShortOffAddr happyDefActions st--{-# LINE 127 "templates/GenericTemplate.hs" #-}---indexShortOffAddr (HappyA# arr) off =-#if __GLASGOW_HASKELL__ > 500-	narrow16Int# i-#elif __GLASGOW_HASKELL__ == 500-	intToInt16# i-#else-	(i `iShiftL#` 16#) `iShiftRA#` 16#-#endif-  where-#if __GLASGOW_HASKELL__ >= 503-	i = word2Int# ((high `uncheckedShiftL#` 8#) `or#` low)-#else-	i = word2Int# ((high `shiftL#` 8#) `or#` low)-#endif-	high = int2Word# (ord# (indexCharOffAddr# arr (off' +# 1#)))-	low  = int2Word# (ord# (indexCharOffAddr# arr off'))-	off' = off *# 2#------data HappyAddr = HappyA# Addr#------------------------------------------------------------------------------------- HappyState data type (not arrays)--{-# LINE 170 "templates/GenericTemplate.hs" #-}---------------------------------------------------------------------------------- Shifting a token--happyShift new_state 0# tk st sts stk@(x `HappyStk` _) =-     let i = (case unsafeCoerce# x of { (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 -# (1# :: 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 +# nt)-             new_state = indexShortOffAddr happyTable off_i-----happyDrop 0# l = l-happyDrop n (HappyCons (_) (t)) = happyDrop (n -# (1# :: Int#)) t--happyDropStk 0# l = l-happyDropStk n (x `HappyStk` xs) = happyDropStk (n -# (1#::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 +# 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 ( (unsafeCoerce# (I# (i))) `HappyStk` stk)---- Internal happy errors:--notHappyAtAll = error "Internal Happy error\n"---------------------------------------------------------------------------------- Hack to get the typechecker to accept our action functions---happyTcHack :: Int# -> a -> a+{-# OPTIONS_GHC -w #-}+{-# OPTIONS -fglasgow-exts -cpp #-}+{-# OPTIONS_HADDOCK hide #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  Language.Haskell.Exts.Annotated.Parser+-- Copyright   :  (c) Niklas Broberg 2004-2009,+--                Original (c) Simon Marlow, Sven Panne 1997-2000+-- License     :  BSD-style (see the file LICENSE.txt)+--+-- Maintainer  :  Niklas Broberg, d00nibro@chalmers.se+-- Stability   :  stable+-- Portability :  portable+--+--+-----------------------------------------------------------------------------+module Language.Haskell.Exts.InternalParser (+              -- * General parsing+              ParseMode(..), defaultParseMode, ParseResult(..), fromParseResult,+              -- * Parsing of specific AST elements+              -- ** Modules+              parseModule, parseModuleWithMode, parseModuleWithComments,+              -- ** Expressions+              parseExp, parseExpWithMode, parseExpWithComments,+              -- ** Statements+              parseStmt, parseStmtWithMode, parseStmtWithComments,+              -- ** Patterns+              parsePat, parsePatWithMode, parsePatWithComments,+              -- ** Declarations+              parseDecl, parseDeclWithMode, parseDeclWithComments,+              -- ** Types+              parseType, parseTypeWithMode, parseTypeWithComments,+              -- ** Multiple modules in one file+              parseModules, parseModulesWithMode, parseModulesWithComments,+              -- ** Option pragmas+              getTopPragmas+              ) where+import Language.Haskell.Exts.Annotated.Syntax hiding ( Type(..), Exp(..), Asst(..), XAttr(..), FieldUpdate(..) )+import Language.Haskell.Exts.Annotated.Syntax ( Type, Exp, Asst )+import Language.Haskell.Exts.ParseMonad+import Language.Haskell.Exts.InternalLexer+import Language.Haskell.Exts.ParseUtils+import Language.Haskell.Exts.Annotated.Fixity+import Language.Haskell.Exts.SrcLoc+import Language.Haskell.Exts.Comments ( Comment )+import Language.Haskell.Exts.Extension++import Control.Monad ( liftM, (<=<) )+import qualified Data.Array as Happy_Data_Array+import qualified GHC.Exts as Happy_GHC_Exts++-- parser produced by Happy Version 1.18.10++newtype HappyAbsSyn  = HappyAbsSyn HappyAny+#if __GLASGOW_HASKELL__ >= 607+type HappyAny = Happy_GHC_Exts.Any+#else+type HappyAny = forall a . a+#endif+happyIn11 :: ([Module L]) -> (HappyAbsSyn )+happyIn11 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn11 #-}+happyOut11 :: (HappyAbsSyn ) -> ([Module L])+happyOut11 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut11 #-}+happyIn12 :: ([[ModulePragma L] -> [S] -> L -> Module L]) -> (HappyAbsSyn )+happyIn12 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn12 #-}+happyOut12 :: (HappyAbsSyn ) -> ([[ModulePragma L] -> [S] -> L -> Module L])+happyOut12 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut12 #-}+happyIn13 :: (Module L) -> (HappyAbsSyn )+happyIn13 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn13 #-}+happyOut13 :: (HappyAbsSyn ) -> (Module L)+happyOut13 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut13 #-}+happyIn14 :: (PExp L) -> (HappyAbsSyn )+happyIn14 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn14 #-}+happyOut14 :: (HappyAbsSyn ) -> (PExp L)+happyOut14 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut14 #-}+happyIn15 :: (([ModulePragma L],[S],L)) -> (HappyAbsSyn )+happyIn15 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn15 #-}+happyOut15 :: (HappyAbsSyn ) -> (([ModulePragma L],[S],L))+happyOut15 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut15 #-}+happyIn16 :: (([ModulePragma L],[S],Maybe L)) -> (HappyAbsSyn )+happyIn16 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn16 #-}+happyOut16 :: (HappyAbsSyn ) -> (([ModulePragma L],[S],Maybe L))+happyOut16 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut16 #-}+happyIn17 :: (ModulePragma L) -> (HappyAbsSyn )+happyIn17 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn17 #-}+happyOut17 :: (HappyAbsSyn ) -> (ModulePragma L)+happyOut17 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut17 #-}+happyIn18 :: (([Name L],[S])) -> (HappyAbsSyn )+happyIn18 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn18 #-}+happyOut18 :: (HappyAbsSyn ) -> (([Name L],[S]))+happyOut18 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut18 #-}+happyIn19 :: ([ModulePragma L] -> [S] -> L -> Module L) -> (HappyAbsSyn )+happyIn19 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn19 #-}+happyOut19 :: (HappyAbsSyn ) -> ([ModulePragma L] -> [S] -> L -> Module L)+happyOut19 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut19 #-}+happyIn20 :: (Maybe (ModuleHead L)) -> (HappyAbsSyn )+happyIn20 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn20 #-}+happyOut20 :: (HappyAbsSyn ) -> (Maybe (ModuleHead L))+happyOut20 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut20 #-}+happyIn21 :: (Maybe (WarningText L)) -> (HappyAbsSyn )+happyIn21 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn21 #-}+happyOut21 :: (HappyAbsSyn ) -> (Maybe (WarningText L))+happyOut21 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut21 #-}+happyIn22 :: (([ImportDecl L],[Decl L],[S],L)) -> (HappyAbsSyn )+happyIn22 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn22 #-}+happyOut22 :: (HappyAbsSyn ) -> (([ImportDecl L],[Decl L],[S],L))+happyOut22 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut22 #-}+happyIn23 :: (([ImportDecl L],[Decl L],[S])) -> (HappyAbsSyn )+happyIn23 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn23 #-}+happyOut23 :: (HappyAbsSyn ) -> (([ImportDecl L],[Decl L],[S]))+happyOut23 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut23 #-}+happyIn24 :: ([S]) -> (HappyAbsSyn )+happyIn24 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn24 #-}+happyOut24 :: (HappyAbsSyn ) -> ([S])+happyOut24 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut24 #-}+happyIn25 :: ([S]) -> (HappyAbsSyn )+happyIn25 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn25 #-}+happyOut25 :: (HappyAbsSyn ) -> ([S])+happyOut25 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut25 #-}+happyIn26 :: (Maybe (ExportSpecList L)) -> (HappyAbsSyn )+happyIn26 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn26 #-}+happyOut26 :: (HappyAbsSyn ) -> (Maybe (ExportSpecList L))+happyOut26 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut26 #-}+happyIn27 :: (ExportSpecList L) -> (HappyAbsSyn )+happyIn27 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn27 #-}+happyOut27 :: (HappyAbsSyn ) -> (ExportSpecList L)+happyOut27 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut27 #-}+happyIn28 :: ([S]) -> (HappyAbsSyn )+happyIn28 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn28 #-}+happyOut28 :: (HappyAbsSyn ) -> ([S])+happyOut28 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut28 #-}+happyIn29 :: (([ExportSpec L],[S])) -> (HappyAbsSyn )+happyIn29 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn29 #-}+happyOut29 :: (HappyAbsSyn ) -> (([ExportSpec L],[S]))+happyOut29 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut29 #-}+happyIn30 :: (ExportSpec L) -> (HappyAbsSyn )+happyIn30 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn30 #-}+happyOut30 :: (HappyAbsSyn ) -> (ExportSpec L)+happyOut30 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut30 #-}+happyIn31 :: (([ImportDecl L],[S])) -> (HappyAbsSyn )+happyIn31 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn31 #-}+happyOut31 :: (HappyAbsSyn ) -> (([ImportDecl L],[S]))+happyOut31 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut31 #-}+happyIn32 :: (ImportDecl L) -> (HappyAbsSyn )+happyIn32 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn32 #-}+happyOut32 :: (HappyAbsSyn ) -> (ImportDecl L)+happyOut32 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut32 #-}+happyIn33 :: ((Bool,[S])) -> (HappyAbsSyn )+happyIn33 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn33 #-}+happyOut33 :: (HappyAbsSyn ) -> ((Bool,[S]))+happyOut33 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut33 #-}+happyIn34 :: ((Bool,[S])) -> (HappyAbsSyn )+happyIn34 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn34 #-}+happyOut34 :: (HappyAbsSyn ) -> ((Bool,[S]))+happyOut34 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut34 #-}+happyIn35 :: ((Maybe String,[S])) -> (HappyAbsSyn )+happyIn35 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn35 #-}+happyOut35 :: (HappyAbsSyn ) -> ((Maybe String,[S]))+happyOut35 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut35 #-}+happyIn36 :: ((Maybe (ModuleName L),[S],Maybe L)) -> (HappyAbsSyn )+happyIn36 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn36 #-}+happyOut36 :: (HappyAbsSyn ) -> ((Maybe (ModuleName L),[S],Maybe L))+happyOut36 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut36 #-}+happyIn37 :: (Maybe (ImportSpecList L)) -> (HappyAbsSyn )+happyIn37 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn37 #-}+happyOut37 :: (HappyAbsSyn ) -> (Maybe (ImportSpecList L))+happyOut37 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut37 #-}+happyIn38 :: (ImportSpecList L) -> (HappyAbsSyn )+happyIn38 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn38 #-}+happyOut38 :: (HappyAbsSyn ) -> (ImportSpecList L)+happyOut38 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut38 #-}+happyIn39 :: ((Bool, Maybe L,[S])) -> (HappyAbsSyn )+happyIn39 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn39 #-}+happyOut39 :: (HappyAbsSyn ) -> ((Bool, Maybe L,[S]))+happyOut39 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut39 #-}+happyIn40 :: (([ImportSpec L],[S])) -> (HappyAbsSyn )+happyIn40 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn40 #-}+happyOut40 :: (HappyAbsSyn ) -> (([ImportSpec L],[S]))+happyOut40 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut40 #-}+happyIn41 :: (ImportSpec L) -> (HappyAbsSyn )+happyIn41 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn41 #-}+happyOut41 :: (HappyAbsSyn ) -> (ImportSpec L)+happyOut41 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut41 #-}+happyIn42 :: (([CName L],[S])) -> (HappyAbsSyn )+happyIn42 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn42 #-}+happyOut42 :: (HappyAbsSyn ) -> (([CName L],[S]))+happyOut42 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut42 #-}+happyIn43 :: (CName L) -> (HappyAbsSyn )+happyIn43 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn43 #-}+happyOut43 :: (HappyAbsSyn ) -> (CName L)+happyOut43 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut43 #-}+happyIn44 :: (Decl L) -> (HappyAbsSyn )+happyIn44 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn44 #-}+happyOut44 :: (HappyAbsSyn ) -> (Decl L)+happyOut44 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut44 #-}+happyIn45 :: ((Maybe Int, [S])) -> (HappyAbsSyn )+happyIn45 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn45 #-}+happyOut45 :: (HappyAbsSyn ) -> ((Maybe Int, [S]))+happyOut45 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut45 #-}+happyIn46 :: (Assoc L) -> (HappyAbsSyn )+happyIn46 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn46 #-}+happyOut46 :: (HappyAbsSyn ) -> (Assoc L)+happyOut46 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut46 #-}+happyIn47 :: (([Op L],[S],L)) -> (HappyAbsSyn )+happyIn47 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn47 #-}+happyOut47 :: (HappyAbsSyn ) -> (([Op L],[S],L))+happyOut47 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut47 #-}+happyIn48 :: (([Decl L],[S])) -> (HappyAbsSyn )+happyIn48 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn48 #-}+happyOut48 :: (HappyAbsSyn ) -> (([Decl L],[S]))+happyOut48 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut48 #-}+happyIn49 :: (([Decl L],[S])) -> (HappyAbsSyn )+happyIn49 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn49 #-}+happyOut49 :: (HappyAbsSyn ) -> (([Decl L],[S]))+happyOut49 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut49 #-}+happyIn50 :: (Decl L) -> (HappyAbsSyn )+happyIn50 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn50 #-}+happyOut50 :: (HappyAbsSyn ) -> (Decl L)+happyOut50 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut50 #-}+happyIn51 :: (DataOrNew L) -> (HappyAbsSyn )+happyIn51 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn51 #-}+happyOut51 :: (HappyAbsSyn ) -> (DataOrNew L)+happyOut51 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut51 #-}+happyIn52 :: (([Type L],[S])) -> (HappyAbsSyn )+happyIn52 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn52 #-}+happyOut52 :: (HappyAbsSyn ) -> (([Type L],[S]))+happyOut52 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut52 #-}+happyIn53 :: (([Decl L],[S])) -> (HappyAbsSyn )+happyIn53 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn53 #-}+happyOut53 :: (HappyAbsSyn ) -> (([Decl L],[S]))+happyOut53 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut53 #-}+happyIn54 :: (([Decl L],[S])) -> (HappyAbsSyn )+happyIn54 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn54 #-}+happyOut54 :: (HappyAbsSyn ) -> (([Decl L],[S]))+happyOut54 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut54 #-}+happyIn55 :: (Decl L) -> (HappyAbsSyn )+happyIn55 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn55 #-}+happyOut55 :: (HappyAbsSyn ) -> (Decl L)+happyOut55 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut55 #-}+happyIn56 :: (Binds L) -> (HappyAbsSyn )+happyIn56 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn56 #-}+happyOut56 :: (HappyAbsSyn ) -> (Binds L)+happyOut56 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut56 #-}+happyIn57 :: (Decl L) -> (HappyAbsSyn )+happyIn57 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn57 #-}+happyOut57 :: (HappyAbsSyn ) -> (Decl L)+happyOut57 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut57 #-}+happyIn58 :: (Decl L) -> (HappyAbsSyn )+happyIn58 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn58 #-}+happyOut58 :: (HappyAbsSyn ) -> (Decl L)+happyOut58 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut58 #-}+happyIn59 :: (([Type L],[S])) -> (HappyAbsSyn )+happyIn59 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn59 #-}+happyOut59 :: (HappyAbsSyn ) -> (([Type L],[S]))+happyOut59 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut59 #-}+happyIn60 :: (Type L) -> (HappyAbsSyn )+happyIn60 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn60 #-}+happyOut60 :: (HappyAbsSyn ) -> (Type L)+happyOut60 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut60 #-}+happyIn61 :: (Binds L) -> (HappyAbsSyn )+happyIn61 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn61 #-}+happyOut61 :: (HappyAbsSyn ) -> (Binds L)+happyOut61 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut61 #-}+happyIn62 :: (([Name L],[S],L)) -> (HappyAbsSyn )+happyIn62 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn62 #-}+happyOut62 :: (HappyAbsSyn ) -> (([Name L],[S],L))+happyOut62 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut62 #-}+happyIn63 :: (CallConv L) -> (HappyAbsSyn )+happyIn63 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn63 #-}+happyOut63 :: (HappyAbsSyn ) -> (CallConv L)+happyOut63 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut63 #-}+happyIn64 :: (Maybe (Safety L)) -> (HappyAbsSyn )+happyIn64 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn64 #-}+happyOut64 :: (HappyAbsSyn ) -> (Maybe (Safety L))+happyOut64 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut64 #-}+happyIn65 :: ((Maybe String, Name L, Type L, [S])) -> (HappyAbsSyn )+happyIn65 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn65 #-}+happyOut65 :: (HappyAbsSyn ) -> ((Maybe String, Name L, Type L, [S]))+happyOut65 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut65 #-}+happyIn66 :: ([Rule L]) -> (HappyAbsSyn )+happyIn66 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn66 #-}+happyOut66 :: (HappyAbsSyn ) -> ([Rule L])+happyOut66 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut66 #-}+happyIn67 :: (Rule L) -> (HappyAbsSyn )+happyIn67 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn67 #-}+happyOut67 :: (HappyAbsSyn ) -> (Rule L)+happyOut67 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut67 #-}+happyIn68 :: (Maybe (Activation L)) -> (HappyAbsSyn )+happyIn68 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn68 #-}+happyOut68 :: (HappyAbsSyn ) -> (Maybe (Activation L))+happyOut68 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut68 #-}+happyIn69 :: ((Maybe [RuleVar L],[S])) -> (HappyAbsSyn )+happyIn69 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn69 #-}+happyOut69 :: (HappyAbsSyn ) -> ((Maybe [RuleVar L],[S]))+happyOut69 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut69 #-}+happyIn70 :: ([RuleVar L]) -> (HappyAbsSyn )+happyIn70 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn70 #-}+happyOut70 :: (HappyAbsSyn ) -> ([RuleVar L])+happyOut70 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut70 #-}+happyIn71 :: (RuleVar L) -> (HappyAbsSyn )+happyIn71 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn71 #-}+happyOut71 :: (HappyAbsSyn ) -> (RuleVar L)+happyOut71 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut71 #-}+happyIn72 :: (([([Name L],String)],[S])) -> (HappyAbsSyn )+happyIn72 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn72 #-}+happyOut72 :: (HappyAbsSyn ) -> (([([Name L],String)],[S]))+happyOut72 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut72 #-}+happyIn73 :: ((([Name L], String),[S])) -> (HappyAbsSyn )+happyIn73 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn73 #-}+happyOut73 :: (HappyAbsSyn ) -> ((([Name L], String),[S]))+happyOut73 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut73 #-}+happyIn74 :: (([Name L],[S])) -> (HappyAbsSyn )+happyIn74 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn74 #-}+happyOut74 :: (HappyAbsSyn ) -> (([Name L],[S]))+happyOut74 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut74 #-}+happyIn75 :: (Name L) -> (HappyAbsSyn )+happyIn75 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn75 #-}+happyOut75 :: (HappyAbsSyn ) -> (Name L)+happyOut75 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut75 #-}+happyIn76 :: (Annotation L) -> (HappyAbsSyn )+happyIn76 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn76 #-}+happyOut76 :: (HappyAbsSyn ) -> (Annotation L)+happyOut76 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut76 #-}+happyIn77 :: (Type L) -> (HappyAbsSyn )+happyIn77 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn77 #-}+happyOut77 :: (HappyAbsSyn ) -> (Type L)+happyOut77 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut77 #-}+happyIn78 :: (PType L) -> (HappyAbsSyn )+happyIn78 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn78 #-}+happyOut78 :: (HappyAbsSyn ) -> (PType L)+happyOut78 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut78 #-}+happyIn79 :: (Type L) -> (HappyAbsSyn )+happyIn79 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn79 #-}+happyOut79 :: (HappyAbsSyn ) -> (Type L)+happyOut79 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut79 #-}+happyIn80 :: (PType L) -> (HappyAbsSyn )+happyIn80 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn80 #-}+happyOut80 :: (HappyAbsSyn ) -> (PType L)+happyOut80 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut80 #-}+happyIn81 :: (Type L) -> (HappyAbsSyn )+happyIn81 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn81 #-}+happyOut81 :: (HappyAbsSyn ) -> (Type L)+happyOut81 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut81 #-}+happyIn82 :: (PType L) -> (HappyAbsSyn )+happyIn82 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn82 #-}+happyOut82 :: (HappyAbsSyn ) -> (PType L)+happyOut82 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut82 #-}+happyIn83 :: (Type L) -> (HappyAbsSyn )+happyIn83 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn83 #-}+happyOut83 :: (HappyAbsSyn ) -> (Type L)+happyOut83 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut83 #-}+happyIn84 :: (PType L) -> (HappyAbsSyn )+happyIn84 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn84 #-}+happyOut84 :: (HappyAbsSyn ) -> (PType L)+happyOut84 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut84 #-}+happyIn85 :: (QName L) -> (HappyAbsSyn )+happyIn85 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn85 #-}+happyOut85 :: (HappyAbsSyn ) -> (QName L)+happyOut85 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut85 #-}+happyIn86 :: (QName L) -> (HappyAbsSyn )+happyIn86 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn86 #-}+happyOut86 :: (HappyAbsSyn ) -> (QName L)+happyOut86 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut86 #-}+happyIn87 :: (QName L) -> (HappyAbsSyn )+happyIn87 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn87 #-}+happyOut87 :: (HappyAbsSyn ) -> (QName L)+happyOut87 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut87 #-}+happyIn88 :: (Type L) -> (HappyAbsSyn )+happyIn88 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn88 #-}+happyOut88 :: (HappyAbsSyn ) -> (Type L)+happyOut88 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut88 #-}+happyIn89 :: (PType L) -> (HappyAbsSyn )+happyIn89 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn89 #-}+happyOut89 :: (HappyAbsSyn ) -> (PType L)+happyOut89 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut89 #-}+happyIn90 :: (PContext L) -> (HappyAbsSyn )+happyIn90 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn90 #-}+happyOut90 :: (HappyAbsSyn ) -> (PContext L)+happyOut90 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut90 #-}+happyIn91 :: (([PType L],[S])) -> (HappyAbsSyn )+happyIn91 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn91 #-}+happyOut91 :: (HappyAbsSyn ) -> (([PType L],[S]))+happyOut91 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut91 #-}+happyIn92 :: (([PType L],[S])) -> (HappyAbsSyn )+happyIn92 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn92 #-}+happyOut92 :: (HappyAbsSyn ) -> (([PType L],[S]))+happyOut92 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut92 #-}+happyIn93 :: (([TyVarBind L],Maybe L)) -> (HappyAbsSyn )+happyIn93 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn93 #-}+happyOut93 :: (HappyAbsSyn ) -> (([TyVarBind L],Maybe L))+happyOut93 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut93 #-}+happyIn94 :: (TyVarBind L) -> (HappyAbsSyn )+happyIn94 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn94 #-}+happyOut94 :: (HappyAbsSyn ) -> (TyVarBind L)+happyOut94 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut94 #-}+happyIn95 :: (([Name L],Maybe L)) -> (HappyAbsSyn )+happyIn95 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn95 #-}+happyOut95 :: (HappyAbsSyn ) -> (([Name L],Maybe L))+happyOut95 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut95 #-}+happyIn96 :: (([Name L],L)) -> (HappyAbsSyn )+happyIn96 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn96 #-}+happyOut96 :: (HappyAbsSyn ) -> (([Name L],L))+happyOut96 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut96 #-}+happyIn97 :: (([FunDep L],[S],Maybe L)) -> (HappyAbsSyn )+happyIn97 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn97 #-}+happyOut97 :: (HappyAbsSyn ) -> (([FunDep L],[S],Maybe L))+happyOut97 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut97 #-}+happyIn98 :: (([FunDep L],[S],L)) -> (HappyAbsSyn )+happyIn98 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn98 #-}+happyOut98 :: (HappyAbsSyn ) -> (([FunDep L],[S],L))+happyOut98 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut98 #-}+happyIn99 :: (FunDep L) -> (HappyAbsSyn )+happyIn99 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn99 #-}+happyOut99 :: (HappyAbsSyn ) -> (FunDep L)+happyOut99 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut99 #-}+happyIn100 :: (([GadtDecl L],[S],Maybe L)) -> (HappyAbsSyn )+happyIn100 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn100 #-}+happyOut100 :: (HappyAbsSyn ) -> (([GadtDecl L],[S],Maybe L))+happyOut100 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut100 #-}+happyIn101 :: (([GadtDecl L],[S])) -> (HappyAbsSyn )+happyIn101 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn101 #-}+happyOut101 :: (HappyAbsSyn ) -> (([GadtDecl L],[S]))+happyOut101 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut101 #-}+happyIn102 :: (([GadtDecl L],[S])) -> (HappyAbsSyn )+happyIn102 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn102 #-}+happyOut102 :: (HappyAbsSyn ) -> (([GadtDecl L],[S]))+happyOut102 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut102 #-}+happyIn103 :: (GadtDecl L) -> (HappyAbsSyn )+happyIn103 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn103 #-}+happyOut103 :: (HappyAbsSyn ) -> (GadtDecl L)+happyOut103 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut103 #-}+happyIn104 :: (([QualConDecl L],[S],Maybe L)) -> (HappyAbsSyn )+happyIn104 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn104 #-}+happyOut104 :: (HappyAbsSyn ) -> (([QualConDecl L],[S],Maybe L))+happyOut104 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut104 #-}+happyIn105 :: (([QualConDecl L],[S],L)) -> (HappyAbsSyn )+happyIn105 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn105 #-}+happyOut105 :: (HappyAbsSyn ) -> (([QualConDecl L],[S],L))+happyOut105 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut105 #-}+happyIn106 :: (QualConDecl L) -> (HappyAbsSyn )+happyIn106 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn106 #-}+happyOut106 :: (HappyAbsSyn ) -> (QualConDecl L)+happyOut106 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut106 #-}+happyIn107 :: ((Maybe [TyVarBind L], [S], Maybe L)) -> (HappyAbsSyn )+happyIn107 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn107 #-}+happyOut107 :: (HappyAbsSyn ) -> ((Maybe [TyVarBind L], [S], Maybe L))+happyOut107 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut107 #-}+happyIn108 :: (ConDecl L) -> (HappyAbsSyn )+happyIn108 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn108 #-}+happyOut108 :: (HappyAbsSyn ) -> (ConDecl L)+happyOut108 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut108 #-}+happyIn109 :: ((Name L, [BangType L], L)) -> (HappyAbsSyn )+happyIn109 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn109 #-}+happyOut109 :: (HappyAbsSyn ) -> ((Name L, [BangType L], L))+happyOut109 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut109 #-}+happyIn110 :: ((Name L, [BangType L],L)) -> (HappyAbsSyn )+happyIn110 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn110 #-}+happyOut110 :: (HappyAbsSyn ) -> ((Name L, [BangType L],L))+happyOut110 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut110 #-}+happyIn111 :: (BangType L) -> (HappyAbsSyn )+happyIn111 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn111 #-}+happyOut111 :: (HappyAbsSyn ) -> (BangType L)+happyOut111 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut111 #-}+happyIn112 :: (BangType L) -> (HappyAbsSyn )+happyIn112 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn112 #-}+happyOut112 :: (HappyAbsSyn ) -> (BangType L)+happyOut112 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut112 #-}+happyIn113 :: (([FieldDecl L],[S])) -> (HappyAbsSyn )+happyIn113 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn113 #-}+happyOut113 :: (HappyAbsSyn ) -> (([FieldDecl L],[S]))+happyOut113 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut113 #-}+happyIn114 :: (FieldDecl L) -> (HappyAbsSyn )+happyIn114 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn114 #-}+happyOut114 :: (HappyAbsSyn ) -> (FieldDecl L)+happyOut114 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut114 #-}+happyIn115 :: (BangType L) -> (HappyAbsSyn )+happyIn115 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn115 #-}+happyOut115 :: (HappyAbsSyn ) -> (BangType L)+happyOut115 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut115 #-}+happyIn116 :: (Maybe (Deriving L)) -> (HappyAbsSyn )+happyIn116 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn116 #-}+happyOut116 :: (HappyAbsSyn ) -> (Maybe (Deriving L))+happyOut116 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut116 #-}+happyIn117 :: (([InstHead L],[S])) -> (HappyAbsSyn )+happyIn117 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn117 #-}+happyOut117 :: (HappyAbsSyn ) -> (([InstHead L],[S]))+happyOut117 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut117 #-}+happyIn118 :: (QName L) -> (HappyAbsSyn )+happyIn118 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn118 #-}+happyOut118 :: (HappyAbsSyn ) -> (QName L)+happyOut118 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut118 #-}+happyIn119 :: (Kind L) -> (HappyAbsSyn )+happyIn119 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn119 #-}+happyOut119 :: (HappyAbsSyn ) -> (Kind L)+happyOut119 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut119 #-}+happyIn120 :: (Kind L) -> (HappyAbsSyn )+happyIn120 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn120 #-}+happyOut120 :: (HappyAbsSyn ) -> (Kind L)+happyOut120 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut120 #-}+happyIn121 :: (Kind L) -> (HappyAbsSyn )+happyIn121 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn121 #-}+happyOut121 :: (HappyAbsSyn ) -> (Kind L)+happyOut121 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut121 #-}+happyIn122 :: ((Maybe (Kind L), [S])) -> (HappyAbsSyn )+happyIn122 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn122 #-}+happyOut122 :: (HappyAbsSyn ) -> ((Maybe (Kind L), [S]))+happyOut122 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut122 #-}+happyIn123 :: ((Maybe [ClassDecl L],[S],Maybe L)) -> (HappyAbsSyn )+happyIn123 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn123 #-}+happyOut123 :: (HappyAbsSyn ) -> ((Maybe [ClassDecl L],[S],Maybe L))+happyOut123 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut123 #-}+happyIn124 :: (([ClassDecl L],[S])) -> (HappyAbsSyn )+happyIn124 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn124 #-}+happyOut124 :: (HappyAbsSyn ) -> (([ClassDecl L],[S]))+happyOut124 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut124 #-}+happyIn125 :: (([ClassDecl L],[S])) -> (HappyAbsSyn )+happyIn125 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn125 #-}+happyOut125 :: (HappyAbsSyn ) -> (([ClassDecl L],[S]))+happyOut125 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut125 #-}+happyIn126 :: (ClassDecl L) -> (HappyAbsSyn )+happyIn126 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn126 #-}+happyOut126 :: (HappyAbsSyn ) -> (ClassDecl L)+happyOut126 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut126 #-}+happyIn127 :: (ClassDecl L) -> (HappyAbsSyn )+happyIn127 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn127 #-}+happyOut127 :: (HappyAbsSyn ) -> (ClassDecl L)+happyOut127 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut127 #-}+happyIn128 :: ((Maybe [InstDecl L],[S],Maybe L)) -> (HappyAbsSyn )+happyIn128 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn128 #-}+happyOut128 :: (HappyAbsSyn ) -> ((Maybe [InstDecl L],[S],Maybe L))+happyOut128 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut128 #-}+happyIn129 :: (([InstDecl L],[S])) -> (HappyAbsSyn )+happyIn129 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn129 #-}+happyOut129 :: (HappyAbsSyn ) -> (([InstDecl L],[S]))+happyOut129 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut129 #-}+happyIn130 :: (([InstDecl L],[S])) -> (HappyAbsSyn )+happyIn130 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn130 #-}+happyOut130 :: (HappyAbsSyn ) -> (([InstDecl L],[S]))+happyOut130 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut130 #-}+happyIn131 :: (InstDecl L) -> (HappyAbsSyn )+happyIn131 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn131 #-}+happyOut131 :: (HappyAbsSyn ) -> (InstDecl L)+happyOut131 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut131 #-}+happyIn132 :: (InstDecl L) -> (HappyAbsSyn )+happyIn132 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn132 #-}+happyOut132 :: (HappyAbsSyn ) -> (InstDecl L)+happyOut132 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut132 #-}+happyIn133 :: (Decl L) -> (HappyAbsSyn )+happyIn133 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn133 #-}+happyOut133 :: (HappyAbsSyn ) -> (Decl L)+happyOut133 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut133 #-}+happyIn134 :: ((Maybe (Binds L),[S])) -> (HappyAbsSyn )+happyIn134 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn134 #-}+happyOut134 :: (HappyAbsSyn ) -> ((Maybe (Binds L),[S]))+happyOut134 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut134 #-}+happyIn135 :: ((Maybe (Type L),[S])) -> (HappyAbsSyn )+happyIn135 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn135 #-}+happyOut135 :: (HappyAbsSyn ) -> ((Maybe (Type L),[S]))+happyOut135 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut135 #-}+happyIn136 :: (Rhs L) -> (HappyAbsSyn )+happyIn136 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn136 #-}+happyOut136 :: (HappyAbsSyn ) -> (Rhs L)+happyOut136 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut136 #-}+happyIn137 :: (([GuardedRhs L],L)) -> (HappyAbsSyn )+happyIn137 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn137 #-}+happyOut137 :: (HappyAbsSyn ) -> (([GuardedRhs L],L))+happyOut137 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut137 #-}+happyIn138 :: (GuardedRhs L) -> (HappyAbsSyn )+happyIn138 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn138 #-}+happyOut138 :: (HappyAbsSyn ) -> (GuardedRhs L)+happyOut138 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut138 #-}+happyIn139 :: (Exp L) -> (HappyAbsSyn )+happyIn139 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn139 #-}+happyOut139 :: (HappyAbsSyn ) -> (Exp L)+happyOut139 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut139 #-}+happyIn140 :: (PExp L) -> (HappyAbsSyn )+happyIn140 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn140 #-}+happyOut140 :: (HappyAbsSyn ) -> (PExp L)+happyOut140 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut140 #-}+happyIn141 :: (PExp L) -> (HappyAbsSyn )+happyIn141 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn141 #-}+happyOut141 :: (HappyAbsSyn ) -> (PExp L)+happyOut141 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut141 #-}+happyIn142 :: (PExp L) -> (HappyAbsSyn )+happyIn142 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn142 #-}+happyOut142 :: (HappyAbsSyn ) -> (PExp L)+happyOut142 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut142 #-}+happyIn143 :: (PExp L) -> (HappyAbsSyn )+happyIn143 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn143 #-}+happyOut143 :: (HappyAbsSyn ) -> (PExp L)+happyOut143 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut143 #-}+happyIn144 :: (PExp L) -> (HappyAbsSyn )+happyIn144 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn144 #-}+happyOut144 :: (HappyAbsSyn ) -> (PExp L)+happyOut144 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut144 #-}+happyIn145 :: ([S]) -> (HappyAbsSyn )+happyIn145 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn145 #-}+happyOut145 :: (HappyAbsSyn ) -> ([S])+happyOut145 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut145 #-}+happyIn146 :: ([S]) -> (HappyAbsSyn )+happyIn146 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn146 #-}+happyOut146 :: (HappyAbsSyn ) -> ([S])+happyOut146 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut146 #-}+happyIn147 :: (PExp L) -> (HappyAbsSyn )+happyIn147 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn147 #-}+happyOut147 :: (HappyAbsSyn ) -> (PExp L)+happyOut147 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut147 #-}+happyIn148 :: (PExp L) -> (HappyAbsSyn )+happyIn148 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn148 #-}+happyOut148 :: (HappyAbsSyn ) -> (PExp L)+happyOut148 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut148 #-}+happyIn149 :: (PExp L) -> (HappyAbsSyn )+happyIn149 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn149 #-}+happyOut149 :: (HappyAbsSyn ) -> (PExp L)+happyOut149 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut149 #-}+happyIn150 :: ([Pat L]) -> (HappyAbsSyn )+happyIn150 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn150 #-}+happyOut150 :: (HappyAbsSyn ) -> ([Pat L])+happyOut150 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut150 #-}+happyIn151 :: (Pat L) -> (HappyAbsSyn )+happyIn151 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn151 #-}+happyOut151 :: (HappyAbsSyn ) -> (Pat L)+happyOut151 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut151 #-}+happyIn152 :: (PExp L) -> (HappyAbsSyn )+happyIn152 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn152 #-}+happyOut152 :: (HappyAbsSyn ) -> (PExp L)+happyOut152 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut152 #-}+happyIn153 :: (PExp L) -> (HappyAbsSyn )+happyIn153 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn153 #-}+happyOut153 :: (HappyAbsSyn ) -> (PExp L)+happyOut153 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut153 #-}+happyIn154 :: (PExp L) -> (HappyAbsSyn )+happyIn154 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn154 #-}+happyOut154 :: (HappyAbsSyn ) -> (PExp L)+happyOut154 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut154 #-}+happyIn155 :: ([S]) -> (HappyAbsSyn )+happyIn155 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn155 #-}+happyOut155 :: (HappyAbsSyn ) -> ([S])+happyOut155 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut155 #-}+happyIn156 :: (PExp L) -> (HappyAbsSyn )+happyIn156 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn156 #-}+happyOut156 :: (HappyAbsSyn ) -> (PExp L)+happyOut156 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut156 #-}+happyIn157 :: (([Maybe (PExp L)],[S])) -> (HappyAbsSyn )+happyIn157 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn157 #-}+happyOut157 :: (HappyAbsSyn ) -> (([Maybe (PExp L)],[S]))+happyOut157 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut157 #-}+happyIn158 :: (([Maybe (PExp L)],[S])) -> (HappyAbsSyn )+happyIn158 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn158 #-}+happyOut158 :: (HappyAbsSyn ) -> (([Maybe (PExp L)],[S]))+happyOut158 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut158 #-}+happyIn159 :: (([PExp L],[S])) -> (HappyAbsSyn )+happyIn159 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn159 #-}+happyOut159 :: (HappyAbsSyn ) -> (([PExp L],[S]))+happyOut159 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut159 #-}+happyIn160 :: (PExp L) -> (HappyAbsSyn )+happyIn160 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn160 #-}+happyOut160 :: (HappyAbsSyn ) -> (PExp L)+happyOut160 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut160 #-}+happyIn161 :: (PExp L) -> (HappyAbsSyn )+happyIn161 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn161 #-}+happyOut161 :: (HappyAbsSyn ) -> (PExp L)+happyOut161 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut161 #-}+happyIn162 :: ([PExp L]) -> (HappyAbsSyn )+happyIn162 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn162 #-}+happyOut162 :: (HappyAbsSyn ) -> ([PExp L])+happyOut162 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut162 #-}+happyIn163 :: (PExp L) -> (HappyAbsSyn )+happyIn163 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn163 #-}+happyOut163 :: (HappyAbsSyn ) -> (PExp L)+happyOut163 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut163 #-}+happyIn164 :: (XName L) -> (HappyAbsSyn )+happyIn164 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn164 #-}+happyOut164 :: (HappyAbsSyn ) -> (XName L)+happyOut164 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut164 #-}+happyIn165 :: (Loc String) -> (HappyAbsSyn )+happyIn165 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn165 #-}+happyOut165 :: (HappyAbsSyn ) -> (Loc String)+happyOut165 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut165 #-}+happyIn166 :: (Loc String) -> (HappyAbsSyn )+happyIn166 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn166 #-}+happyOut166 :: (HappyAbsSyn ) -> (Loc String)+happyOut166 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut166 #-}+happyIn167 :: ([ParseXAttr L]) -> (HappyAbsSyn )+happyIn167 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn167 #-}+happyOut167 :: (HappyAbsSyn ) -> ([ParseXAttr L])+happyOut167 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut167 #-}+happyIn168 :: (ParseXAttr L) -> (HappyAbsSyn )+happyIn168 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn168 #-}+happyOut168 :: (HappyAbsSyn ) -> (ParseXAttr L)+happyOut168 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut168 #-}+happyIn169 :: (Maybe (PExp L)) -> (HappyAbsSyn )+happyIn169 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn169 #-}+happyOut169 :: (HappyAbsSyn ) -> (Maybe (PExp L))+happyOut169 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut169 #-}+happyIn170 :: (L -> PExp L) -> (HappyAbsSyn )+happyIn170 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn170 #-}+happyOut170 :: (HappyAbsSyn ) -> (L -> PExp L)+happyOut170 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut170 #-}+happyIn171 :: (([PExp L],[S])) -> (HappyAbsSyn )+happyIn171 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn171 #-}+happyOut171 :: (HappyAbsSyn ) -> (([PExp L],[S]))+happyOut171 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut171 #-}+happyIn172 :: (([[QualStmt L]],[S])) -> (HappyAbsSyn )+happyIn172 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn172 #-}+happyOut172 :: (HappyAbsSyn ) -> (([[QualStmt L]],[S]))+happyOut172 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut172 #-}+happyIn173 :: (([QualStmt L],[S])) -> (HappyAbsSyn )+happyIn173 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn173 #-}+happyOut173 :: (HappyAbsSyn ) -> (([QualStmt L],[S]))+happyOut173 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut173 #-}+happyIn174 :: (QualStmt L) -> (HappyAbsSyn )+happyIn174 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn174 #-}+happyOut174 :: (HappyAbsSyn ) -> (QualStmt L)+happyOut174 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut174 #-}+happyIn175 :: (QualStmt L) -> (HappyAbsSyn )+happyIn175 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn175 #-}+happyOut175 :: (HappyAbsSyn ) -> (QualStmt L)+happyOut175 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut175 #-}+happyIn176 :: (([Stmt L],[S])) -> (HappyAbsSyn )+happyIn176 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn176 #-}+happyOut176 :: (HappyAbsSyn ) -> (([Stmt L],[S]))+happyOut176 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut176 #-}+happyIn177 :: (Stmt L) -> (HappyAbsSyn )+happyIn177 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn177 #-}+happyOut177 :: (HappyAbsSyn ) -> (Stmt L)+happyOut177 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut177 #-}+happyIn178 :: (([Alt L],L,[S])) -> (HappyAbsSyn )+happyIn178 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn178 #-}+happyOut178 :: (HappyAbsSyn ) -> (([Alt L],L,[S]))+happyOut178 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut178 #-}+happyIn179 :: (([Alt L],[S])) -> (HappyAbsSyn )+happyIn179 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn179 #-}+happyOut179 :: (HappyAbsSyn ) -> (([Alt L],[S]))+happyOut179 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut179 #-}+happyIn180 :: (([Alt L],[S])) -> (HappyAbsSyn )+happyIn180 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn180 #-}+happyOut180 :: (HappyAbsSyn ) -> (([Alt L],[S]))+happyOut180 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut180 #-}+happyIn181 :: (Alt L) -> (HappyAbsSyn )+happyIn181 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn181 #-}+happyOut181 :: (HappyAbsSyn ) -> (Alt L)+happyOut181 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut181 #-}+happyIn182 :: (GuardedAlts L) -> (HappyAbsSyn )+happyIn182 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn182 #-}+happyOut182 :: (HappyAbsSyn ) -> (GuardedAlts L)+happyOut182 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut182 #-}+happyIn183 :: (([GuardedAlt L],L)) -> (HappyAbsSyn )+happyIn183 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn183 #-}+happyOut183 :: (HappyAbsSyn ) -> (([GuardedAlt L],L))+happyOut183 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut183 #-}+happyIn184 :: (GuardedAlt L) -> (HappyAbsSyn )+happyIn184 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn184 #-}+happyOut184 :: (HappyAbsSyn ) -> (GuardedAlt L)+happyOut184 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut184 #-}+happyIn185 :: (Pat L) -> (HappyAbsSyn )+happyIn185 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn185 #-}+happyOut185 :: (HappyAbsSyn ) -> (Pat L)+happyOut185 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut185 #-}+happyIn186 :: (([Stmt L],L,[S])) -> (HappyAbsSyn )+happyIn186 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn186 #-}+happyOut186 :: (HappyAbsSyn ) -> (([Stmt L],L,[S]))+happyOut186 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut186 #-}+happyIn187 :: (([Stmt L],[S])) -> (HappyAbsSyn )+happyIn187 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn187 #-}+happyOut187 :: (HappyAbsSyn ) -> (([Stmt L],[S]))+happyOut187 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut187 #-}+happyIn188 :: (([Stmt L],[S])) -> (HappyAbsSyn )+happyIn188 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn188 #-}+happyOut188 :: (HappyAbsSyn ) -> (([Stmt L],[S]))+happyOut188 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut188 #-}+happyIn189 :: (Stmt L) -> (HappyAbsSyn )+happyIn189 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn189 #-}+happyOut189 :: (HappyAbsSyn ) -> (Stmt L)+happyOut189 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut189 #-}+happyIn190 :: (([PFieldUpdate L],[S])) -> (HappyAbsSyn )+happyIn190 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn190 #-}+happyOut190 :: (HappyAbsSyn ) -> (([PFieldUpdate L],[S]))+happyOut190 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut190 #-}+happyIn191 :: (PFieldUpdate L) -> (HappyAbsSyn )+happyIn191 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn191 #-}+happyOut191 :: (HappyAbsSyn ) -> (PFieldUpdate L)+happyOut191 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut191 #-}+happyIn192 :: (([IPBind L],[S])) -> (HappyAbsSyn )+happyIn192 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn192 #-}+happyOut192 :: (HappyAbsSyn ) -> (([IPBind L],[S]))+happyOut192 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut192 #-}+happyIn193 :: (([IPBind L],[S])) -> (HappyAbsSyn )+happyIn193 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn193 #-}+happyOut193 :: (HappyAbsSyn ) -> (([IPBind L],[S]))+happyOut193 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut193 #-}+happyIn194 :: (IPBind L) -> (HappyAbsSyn )+happyIn194 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn194 #-}+happyOut194 :: (HappyAbsSyn ) -> (IPBind L)+happyOut194 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut194 #-}+happyIn195 :: (PExp L) -> (HappyAbsSyn )+happyIn195 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn195 #-}+happyOut195 :: (HappyAbsSyn ) -> (PExp L)+happyOut195 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut195 #-}+happyIn196 :: (Name L) -> (HappyAbsSyn )+happyIn196 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn196 #-}+happyOut196 :: (HappyAbsSyn ) -> (Name L)+happyOut196 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut196 #-}+happyIn197 :: (Name L) -> (HappyAbsSyn )+happyIn197 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn197 #-}+happyOut197 :: (HappyAbsSyn ) -> (Name L)+happyOut197 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut197 #-}+happyIn198 :: (QName L) -> (HappyAbsSyn )+happyIn198 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn198 #-}+happyOut198 :: (HappyAbsSyn ) -> (QName L)+happyOut198 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut198 #-}+happyIn199 :: (IPName L) -> (HappyAbsSyn )+happyIn199 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn199 #-}+happyOut199 :: (HappyAbsSyn ) -> (IPName L)+happyOut199 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut199 #-}+happyIn200 :: (Name L) -> (HappyAbsSyn )+happyIn200 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn200 #-}+happyOut200 :: (HappyAbsSyn ) -> (Name L)+happyOut200 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut200 #-}+happyIn201 :: (QName L) -> (HappyAbsSyn )+happyIn201 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn201 #-}+happyOut201 :: (HappyAbsSyn ) -> (QName L)+happyOut201 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut201 #-}+happyIn202 :: (Name L) -> (HappyAbsSyn )+happyIn202 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn202 #-}+happyOut202 :: (HappyAbsSyn ) -> (Name L)+happyOut202 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut202 #-}+happyIn203 :: (QName L) -> (HappyAbsSyn )+happyIn203 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn203 #-}+happyOut203 :: (HappyAbsSyn ) -> (QName L)+happyOut203 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut203 #-}+happyIn204 :: (QName L) -> (HappyAbsSyn )+happyIn204 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn204 #-}+happyOut204 :: (HappyAbsSyn ) -> (QName L)+happyOut204 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut204 #-}+happyIn205 :: (Name L) -> (HappyAbsSyn )+happyIn205 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn205 #-}+happyOut205 :: (HappyAbsSyn ) -> (Name L)+happyOut205 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut205 #-}+happyIn206 :: (QName L) -> (HappyAbsSyn )+happyIn206 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn206 #-}+happyOut206 :: (HappyAbsSyn ) -> (QName L)+happyOut206 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut206 #-}+happyIn207 :: (Op L) -> (HappyAbsSyn )+happyIn207 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn207 #-}+happyOut207 :: (HappyAbsSyn ) -> (Op L)+happyOut207 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut207 #-}+happyIn208 :: (QOp L) -> (HappyAbsSyn )+happyIn208 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn208 #-}+happyOut208 :: (HappyAbsSyn ) -> (QOp L)+happyOut208 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut208 #-}+happyIn209 :: (QOp L) -> (HappyAbsSyn )+happyIn209 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn209 #-}+happyOut209 :: (HappyAbsSyn ) -> (QOp L)+happyOut209 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut209 #-}+happyIn210 :: (QName L) -> (HappyAbsSyn )+happyIn210 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn210 #-}+happyOut210 :: (HappyAbsSyn ) -> (QName L)+happyOut210 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut210 #-}+happyIn211 :: (QName L) -> (HappyAbsSyn )+happyIn211 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn211 #-}+happyOut211 :: (HappyAbsSyn ) -> (QName L)+happyOut211 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut211 #-}+happyIn212 :: (Name L) -> (HappyAbsSyn )+happyIn212 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn212 #-}+happyOut212 :: (HappyAbsSyn ) -> (Name L)+happyOut212 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut212 #-}+happyIn213 :: (Name L) -> (HappyAbsSyn )+happyIn213 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn213 #-}+happyOut213 :: (HappyAbsSyn ) -> (Name L)+happyOut213 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut213 #-}+happyIn214 :: (IPName L) -> (HappyAbsSyn )+happyIn214 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn214 #-}+happyOut214 :: (HappyAbsSyn ) -> (IPName L)+happyOut214 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut214 #-}+happyIn215 :: (QName L) -> (HappyAbsSyn )+happyIn215 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn215 #-}+happyOut215 :: (HappyAbsSyn ) -> (QName L)+happyOut215 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut215 #-}+happyIn216 :: (Name L) -> (HappyAbsSyn )+happyIn216 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn216 #-}+happyOut216 :: (HappyAbsSyn ) -> (Name L)+happyOut216 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut216 #-}+happyIn217 :: (QName L) -> (HappyAbsSyn )+happyIn217 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn217 #-}+happyOut217 :: (HappyAbsSyn ) -> (QName L)+happyOut217 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut217 #-}+happyIn218 :: (Name L) -> (HappyAbsSyn )+happyIn218 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn218 #-}+happyOut218 :: (HappyAbsSyn ) -> (Name L)+happyOut218 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut218 #-}+happyIn219 :: (QName L) -> (HappyAbsSyn )+happyIn219 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn219 #-}+happyOut219 :: (HappyAbsSyn ) -> (QName L)+happyOut219 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut219 #-}+happyIn220 :: (QName L) -> (HappyAbsSyn )+happyIn220 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn220 #-}+happyOut220 :: (HappyAbsSyn ) -> (QName L)+happyOut220 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut220 #-}+happyIn221 :: (Name L) -> (HappyAbsSyn )+happyIn221 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn221 #-}+happyOut221 :: (HappyAbsSyn ) -> (Name L)+happyOut221 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut221 #-}+happyIn222 :: (Name L) -> (HappyAbsSyn )+happyIn222 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn222 #-}+happyOut222 :: (HappyAbsSyn ) -> (Name L)+happyOut222 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut222 #-}+happyIn223 :: (QName L) -> (HappyAbsSyn )+happyIn223 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn223 #-}+happyOut223 :: (HappyAbsSyn ) -> (QName L)+happyOut223 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut223 #-}+happyIn224 :: (Literal L) -> (HappyAbsSyn )+happyIn224 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn224 #-}+happyOut224 :: (HappyAbsSyn ) -> (Literal L)+happyOut224 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut224 #-}+happyIn225 :: (S) -> (HappyAbsSyn )+happyIn225 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn225 #-}+happyOut225 :: (HappyAbsSyn ) -> (S)+happyOut225 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut225 #-}+happyIn226 :: (S) -> (HappyAbsSyn )+happyIn226 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn226 #-}+happyOut226 :: (HappyAbsSyn ) -> (S)+happyOut226 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut226 #-}+happyIn227 :: (ModuleName L) -> (HappyAbsSyn )+happyIn227 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn227 #-}+happyOut227 :: (HappyAbsSyn ) -> (ModuleName L)+happyOut227 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut227 #-}+happyIn228 :: (Name L) -> (HappyAbsSyn )+happyIn228 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn228 #-}+happyOut228 :: (HappyAbsSyn ) -> (Name L)+happyOut228 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut228 #-}+happyIn229 :: (QName L) -> (HappyAbsSyn )+happyIn229 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn229 #-}+happyOut229 :: (HappyAbsSyn ) -> (QName L)+happyOut229 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut229 #-}+happyIn230 :: (Name L) -> (HappyAbsSyn )+happyIn230 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn230 #-}+happyOut230 :: (HappyAbsSyn ) -> (Name L)+happyOut230 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut230 #-}+happyIn231 :: (Name L) -> (HappyAbsSyn )+happyIn231 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn231 #-}+happyOut231 :: (HappyAbsSyn ) -> (Name L)+happyOut231 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut231 #-}+happyIn232 :: (QName L) -> (HappyAbsSyn )+happyIn232 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn232 #-}+happyOut232 :: (HappyAbsSyn ) -> (QName L)+happyOut232 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut232 #-}+happyIn233 :: (Name L) -> (HappyAbsSyn )+happyIn233 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyIn233 #-}+happyOut233 :: (HappyAbsSyn ) -> (Name L)+happyOut233 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut233 #-}+happyInTok :: (Loc Token) -> (HappyAbsSyn )+happyInTok x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyInTok #-}+happyOutTok :: (HappyAbsSyn ) -> (Loc Token)+happyOutTok x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOutTok #-}+++happyActOffsets :: HappyAddr+happyActOffsets = HappyA# "\x00\x00\x47\x15\xcc\x14\x0a\x0b\xe3\x1c\x65\x12\x00\x00\x00\x00\x00\x00\xf2\x06\x14\x04\x62\x07\xd7\x06\x00\x00\x35\x07\x00\x00\x00\x00\xa8\x21\x00\x00\x00\x00\x00\x00\x57\x1a\x00\x00\x43\x07\x00\x00\x00\x00\x31\x07\xd0\x06\x00\x00\xfa\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x71\x0f\xed\x0e\xf5\x0f\x00\x00\xfa\x19\x57\x1a\x57\x1a\x57\x1a\x47\x15\x00\x00\x47\x15\x47\x15\x47\x15\xe3\x1c\x00\x00\xa5\x1e\x08\x20\x00\x00\x77\x1a\x47\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x15\x42\x07\x00\x00\x00\x00\x00\x00\x47\x15\x41\x07\x3d\x07\xfa\x19\x3d\x07\x00\x00\x49\x07\x45\x07\x3f\x07\x00\x00\x00\x00\x4c\x1b\x00\x00\x00\x00\x00\x00\xcf\x06\x00\x00\xe3\x1c\x28\x07\x00\x00\x00\x00\x00\x00\x00\x00\xf2\x1a\xa9\x1b\xd6\x1c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x07\xc9\x06\xf0\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\x0c\x57\x1a\xd7\x00\x7a\x1c\xe5\x06\x33\x07\xd8\x06\x00\x00\x00\x00\x00\x00\x7a\x1c\x2b\x07\x00\x00\x6d\x1d\x26\x07\x26\x07\x16\x00\x26\x07\x32\x07\xb8\x20\xb8\x20\x79\x1e\x00\x00\xb0\x06\xb0\x06\x00\x00\xb0\x06\x0c\x00\x00\x00\x00\x00\x1d\x07\x77\x1a\xce\x06\x74\x05\x57\x1a\xa8\x06\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x57\x1a\x2a\x07\x2c\x00\x00\x00\x1f\x07\x0b\x07\x26\x00\x24\x00\x00\x00\x09\x07\x98\x20\x51\x00\x98\x20\x7a\x1c\x98\x20\x98\x20\x02\x07\x60\x1b\x60\x1d\xdc\x1f\x00\x00\xcd\x06\x00\x00\x00\x00\xaa\x06\x7a\x1c\x7a\x1c\x7a\x1c\xf8\x06\xd1\x03\xd1\x03\xb0\x04\xb0\x04\x00\x00\x00\x00\x47\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\x20\x40\x1d\x00\x00\x00\x00\x7a\x1c\x00\x00\x00\x00\x00\x00\x42\x05\x7a\x1c\x50\x00\x00\x00\x91\x21\xfb\x06\x00\x00\x00\x00\xbc\x02\xa3\x02\x00\x00\x00\x00\xa0\x01\x03\x07\xf7\x06\xa2\x02\x00\x07\xff\x06\x00\x00\xfe\x06\xa8\x1f\x00\x00\x00\x00\xa8\x1f\x00\x00\xa8\x1f\x00\x00\x00\x00\x94\x0b\x7a\x1c\xa8\x1f\x00\x00\x06\x07\x82\x06\x7c\x06\x00\x00\xf4\x10\xf4\x10\xdc\x06\x00\x00\x57\x1a\x00\x00\x9b\x06\xe6\x06\x00\x00\x89\x06\x1c\x00\xb9\x06\x00\x00\xda\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x05\x56\x02\xd6\x06\x00\x00\x00\x00\x09\x05\x0a\x0b\xc3\x06\xc2\x06\x83\x02\xb8\x06\xde\x06\xc8\x06\x1c\x01\x00\x00\x57\x1a\x00\x00\x9d\x19\x00\x00\xbc\x06\x7d\x01\xc4\x06\xba\x06\x00\x00\x00\x00\x47\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbc\x1c\x00\x00\x00\x00\x00\x00\x69\x0e\x3d\x02\x00\x00\xaa\x04\xe5\x0d\x5e\x02\xcc\x06\xca\x06\xc1\x06\xc0\x06\xbf\x06\x00\x00\xbb\x06\x57\x1a\xb6\x06\xb5\x06\x60\x1d\x57\x1a\x57\x1a\x47\x15\x5e\x1e\x00\x00\x47\x15\x7a\x1c\x47\x15\x47\x15\x47\x15\x47\x15\x4d\x00\xa9\x06\x00\x00\xbe\x06\x11\x1e\x00\x00\xac\x00\x00\x00\x37\x06\x00\x00\x9e\x06\x00\x00\x07\x00\x14\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc4\x02\x00\x00\x96\x06\x20\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x06\x00\x00\x00\x00\x00\x00\x00\x00\x61\x0d\x00\x00\x00\x00\x55\x02\x00\x00\x00\x00\x47\x15\x47\x15\xdd\x0c\x00\x00\x00\x00\x0e\x02\x00\x00\x99\x06\x98\x06\x00\x00\x79\x10\x00\x00\x79\x10\x47\x15\xea\x11\x00\x00\x47\x15\x47\x15\x00\x00\x51\x14\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\xa4\x06\x77\x1a\xb1\x18\x00\x00\x72\x06\x00\x00\x00\x00\x00\x00\x00\x00\x47\x15\x92\x06\x3e\x06\x00\x00\x47\x15\x00\x00\x47\x15\x93\x06\x91\x06\xf4\x10\x4d\x00\x47\x15\x47\x15\x84\x06\xfd\x1d\x00\x00\x86\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7a\x1c\x00\x00\x00\x00\xf8\x00\x00\x00\x00\x00\x7a\x1c\x00\x00\x00\x00\x00\x00\xb8\x21\x7a\x1c\x87\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1a\x21\x42\x05\x46\x06\x27\x06\xf8\x00\x41\x06\xe1\x03\x79\x06\x01\x02\x00\x00\x21\x06\x6e\x06\x00\x00\x47\x15\x51\x14\x1a\x06\x23\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x0c\x16\x06\x00\x00\x67\x06\x76\x06\x00\x00\x6c\x06\x00\x00\x00\x00\x00\x00\x6f\x06\x3f\x17\x6d\x06\x62\x06\x4d\x00\x4d\x00\x61\x06\x00\x00\x5f\x06\x7c\x1f\x7a\x1c\xfa\x05\xf9\x05\xf0\x05\x50\x06\x5b\x06\x6b\x06\x4d\x06\x0e\x06\x5d\x06\x00\x00\x71\x20\x00\x00\x71\x20\x00\x00\x00\x00\x57\x1a\x00\x00\x5c\x06\x5a\x06\x00\x00\x00\x00\xe3\x04\x00\x00\x00\x00\x24\x06\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x06\xf6\x09\x4d\x00\xb1\x18\x23\x06\x51\x06\x59\x06\x57\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x15\x00\x21\x7a\x1c\x43\x06\x00\x00\x7a\x1c\x00\x00\x00\x00\x00\x00\x00\x00\x7c\x1f\x00\x00\x7a\x1c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x05\x00\x00\x00\x00\x3c\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x1e\x38\x06\x00\x00\x00\x00\x3b\x06\x00\x00\x2e\x06\x00\x00\xa3\x07\x8d\x01\x05\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x35\x06\x00\x00\x96\x02\x00\x00\x25\x06\x2d\x06\x00\x00\x00\x00\x00\x00\xd1\x20\x7a\x1c\x00\x00\x1b\x06\x00\x00\x7c\x0c\x00\x00\x00\x00\x00\x00\x17\x06\xf8\x00\x00\x00\x00\x00\xe0\x05\x20\x06\x00\x00\x2d\x02\xd4\x05\xc1\x05\x14\x06\x13\x06\x50\x00\x00\x00\x0d\x06\x00\x00\x1d\x06\x11\x06\x00\x00\x00\x00\x22\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf4\x10\x00\x00\x00\x00\x00\x00\x47\x15\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\xdc\x05\x00\x00\x04\x06\x00\x00\x0d\x05\xa8\x04\xa2\x04\x97\x04\x85\x04\x6f\x04\x60\x04\x58\x04\x49\x04\xed\x03\xdf\x03\xa9\x03\x7b\x03\x45\x03\x13\x03\x0b\x03\xe0\x02\xd5\x02\x00\x00\x0a\x0b\x07\x06\xe1\x05\x13\x01\x00\x00\x00\x00\xf5\x05\x03\x06\x00\x00\x00\x00\x00\x00\xd6\x13\x00\x00\x57\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xca\x00\x00\x00\x00\x00\xf4\x05\x00\x00\x00\x00\x00\x00\x37\x02\x00\x00\x00\x00\x47\x15\x00\x00\x61\x1f\x00\x00\x00\x00\x18\x06\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x15\xbf\x05\xe6\xff\xea\x11\xea\x11\x5b\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x1a\x00\x00\x00\x00\x6f\x11\x00\x06\x4d\x00\xf6\x05\x00\x00\xdf\x05\x00\x00\xf8\x00\x00\x00\x00\x00\x00\x00\xb9\x05\x00\x00\x00\x00\x00\x00\xc9\x1b\x00\x00\x00\x00\x00\x00\xf7\x05\xf8\x00\x53\x21\x00\x00\x7b\x0b\x7c\x0c\x00\x00\x00\x00\x37\x0c\xd8\x00\xef\x05\xee\x05\xf2\x1a\x48\x1f\x7b\x05\x98\x05\x00\x00\x00\x00\x8d\x01\x97\x05\x47\x15\x47\x15\x00\x00\x00\x00\xe5\x05\xd2\x05\x48\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x16\xd7\x05\x4d\x00\x47\x15\x3e\x05\xcc\x05\x2c\x19\x32\x18\xcc\x05\x00\x00\x63\x05\xc4\x05\x00\x00\x00\x00\x5f\x05\xbc\x05\x1c\x1c\x00\x00\x33\x21\xb2\x05\x52\x05\x51\x05\x5d\x05\x00\x00\x4e\x1c\x00\x00\xf5\x04\x00\x00\x00\x00\x00\x00\x00\x00\x59\x05\x00\x00\x4d\x05\x3f\x05\x80\x0a\xa9\x05\x00\x00\x00\x00\xb0\x05\xa1\x05\x00\x00\x00\x00\x00\x00\xae\x05\x00\x00\x38\x05\x00\x00\x00\x00\x00\x00\x47\x15\x93\x05\x00\x00\x00\x00\x00\x00\x35\x1c\x00\x00\x00\x00\x00\x00\x90\x05\x00\x00\x00\x00\x00\x00\x35\x1c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x1b\x00\x00\x48\x1f\xb8\x21\x00\x00\x00\x00\xc2\x15\x99\x05\x4d\x00\x00\x00\x48\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x83\x05\x00\x00\x00\x00\x9d\x05\xee\x1e\x1e\x0c\xac\x05\x00\x00\x00\x00\x1c\x1f\x28\x05\xd9\x0b\x00\x00\x1c\x1f\x1c\x1f\x27\x05\x00\x00\x00\x00\x00\x00\x75\x01\x92\x05\x4d\x00\x88\x05\x8f\x05\x00\x00\x00\x00\x8b\x05\x91\x05\x40\x05\x00\x00\x00\x00\x00\x00\x00\x00\x79\x02\x00\x00\x1c\x00\x00\x00\x77\x05\x00\x00\x47\x15\x47\x15\x47\x15\x00\x00\x00\x00\x00\x00\x1f\x05\x50\x05\x1b\x05\x6b\x05\x00\x00\x5b\x13\x47\x15\xe0\x12\x78\x05\x47\x15\x69\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x66\x05\x30\x00\x61\x05\x00\x00\xfd\x1d\x5b\x05\x00\x00\x1c\x1f\x00\x00\x3a\x01\xb9\x02\x00\x00\x00\x00\x6c\x05\x1c\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x35\x1c\x60\x1d\x9e\x21\x5c\x05\x35\x1c\xb3\x17\x68\x05\x0e\x05\x00\x00\x35\x1c\x00\x00\x00\x00\xe2\x1d\x6a\x05\x03\x1d\x00\x00\x17\x03\x00\x00\x00\x00\x00\x00\x71\x05\x00\x00\x26\x05\x00\x00\x77\x1a\x00\x00\x00\x00\x33\x02\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x05\x57\x05\x13\x05\xf2\x04\x00\x00\x00\x00\x35\x1c\x3a\x05\x36\x05\x35\x05\x35\x05\x41\x16\x3d\x05\x00\x00\x00\x00\x3c\x20\xc0\x0b\x1c\x1f\x1c\x1f\x35\x1c\xfd\x01\x3d\x05\x39\x05\x00\x00\x00\x00\x00\x00\x04\x02\x00\x00\x00\x00\x77\x1a\x47\x15\x00\x00\x11\x05\x47\x15\xc0\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x1f\xbc\x04\x00\x00\x00\x00\x00\x00\x00\x00\x35\x1c\x00\x00\xe7\x04\x00\x00\x00\x00\x00\x00\x00\x00\x15\x20\xe5\x04\xd6\x04\x0b\x00\x26\x05\x00\x00\x00\x00\x00\x00\x00\x00\xfb\x04\x00\x00\x47\x15\x00\x00\x00\x00\x00\x00\x1c\x1f\x00\x00\x00\x00\x00\x00\x0f\x05\x00\x00\xc0\x1e\x00\x00\x0c\x05\xfd\x04\x00\x00\x00\x00\x00\x00\x05\x05\xc9\x1d\x02\x05\x15\x20\x00\x00\x00\x00\x00\x00\xa1\x01\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00"#++happyGotoOffsets :: HappyAddr+happyGotoOffsets = HappyA# "\x02\x00\x27\x28\x3e\x2b\xb2\x01\xb1\x06\xf4\x24\x01\x00\xff\xff\xfe\xff\x0c\x03\x22\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x06\x00\x00\x00\x00\x00\x00\xb5\x31\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x28\xb2\x28\x92\x28\x00\x00\x9e\x16\x9f\x31\x93\x17\x67\x31\x28\x2b\x00\x00\xd9\x27\xc1\x27\xd8\x2f\x9d\x06\x39\x04\x7d\x02\x87\x05\x00\x00\xf1\x03\x26\x2f\x70\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x2f\x9c\xff\x00\x00\x00\x00\x00\x00\xc2\x2e\x0a\x00\x92\xff\x5b\x19\x90\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x04\xbf\x04\x8f\x08\x00\x00\x00\x00\x00\x00\xb3\x04\x00\x00\xcd\x04\x00\x00\x46\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x09\x51\x31\x00\x00\x03\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xef\x07\xf5\xff\x00\x00\x32\x08\xca\x04\xc5\x04\xba\x04\xb1\x04\xd4\x04\x83\x03\x59\x02\x2e\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x01\x00\x00\x00\x00\xfc\xff\xe3\x03\xe0\x04\x19\x04\x19\x31\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x77\x01\x03\x31\x17\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x04\x85\x02\x00\x00\x54\x02\xbb\x07\xc8\x01\x99\x01\x00\x00\xad\x08\x7b\x08\xce\x03\x00\x00\x00\x00\x1b\x00\x10\x00\x6d\x04\xa7\x07\x49\x01\x93\x07\x80\x04\x9e\x04\x9a\x04\xf9\x03\xd4\x03\x00\x00\x00\x00\xc2\x2f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x00\xf0\x03\x00\x00\x00\x00\x69\x06\x00\x00\x00\x00\x00\x00\xb3\x01\x55\x06\xec\xff\x00\x00\x31\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x03\x00\x00\x00\x00\x87\x02\x00\x00\x16\x01\x00\x00\x00\x00\x20\x01\x64\x07\xad\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x24\x0a\x24\x00\x00\x00\x00\xcb\x30\x00\x00\x00\x00\x35\x04\x00\x00\x00\x00\xa5\x00\x00\x00\x09\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\x8c\xff\x12\x04\x00\x00\x00\x00\x00\x00\x2b\x02\x2c\x01\x00\x00\x00\x00\x06\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\x30\x00\x00\x59\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8a\x2f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x03\x00\x00\x00\x00\x00\x00\x0b\x2a\x76\x01\x00\x00\x00\x00\xed\x29\xce\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x93\x17\x00\x00\x00\x00\x21\x08\x7d\x30\x67\x30\x73\x27\xa3\x00\x00\x00\xc2\x2f\x12\x06\xac\x2e\x5e\x2e\x48\x2e\xfa\x2d\xd9\x03\x00\x00\x50\x04\x0f\x00\xb6\x00\x00\x00\xdf\x02\x00\x00\x00\x00\x41\x04\x00\x00\x00\x00\x00\x00\x8d\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\x02\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\x29\x00\x00\x00\x00\x10\x01\x00\x00\x00\x00\xda\x2a\xe4\x2d\x7a\x29\x00\x00\x00\x00\x5b\x01\x00\x00\x00\x00\x00\x00\x00\x00\x25\x29\x00\x00\x07\x29\x96\x2d\x9a\x21\x00\x00\x80\x2d\x32\x2d\x00\x00\xbc\x23\x00\x00\x00\x00\x00\x00\x00\x00\xc2\x03\x3d\x04\x00\x00\x00\x00\x89\x03\x2f\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc4\x2a\x7f\xff\x00\x00\x00\x00\x1c\x2d\x00\x00\xce\x2c\x00\x00\xdd\x03\x6e\x23\xa2\x03\xb8\x2c\x6a\x2c\x00\x00\xd1\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x50\x07\x00\x00\x00\x00\xcb\x03\x00\x00\x00\x00\x08\x07\x00\x00\x00\x00\x00\x00\x14\x01\xf4\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x64\x02\xa2\x01\xfe\x03\x0a\x04\x91\x03\xcf\x03\x00\x00\x00\x00\x00\x00\x00\x00\xf2\x03\xbf\x03\x00\x00\x5b\x27\x20\x23\xef\x03\x05\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\xff\xc3\x03\xb0\x01\xe8\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x03\x39\x02\x00\x00\x00\x00\x43\x03\x2e\x03\x00\x00\x00\x00\x81\x03\xb6\x04\xfe\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x03\xa5\x03\x00\x00\x9c\x03\x00\x00\x8e\x01\x00\x00\x00\x00\x71\x1a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc9\x03\x00\x00\x00\x00\x00\x00\x33\x03\x00\x00\xec\x03\xd2\x03\x00\x00\x65\x00\xe7\x02\x19\x30\xae\x03\xa6\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x74\x2f\xdc\xff\xc4\x03\x00\x00\x00\x00\xa8\x03\x00\x00\x00\x00\x00\x00\x00\x00\xd1\x01\x00\x00\xca\x05\x00\x00\x00\x00\x00\x00\x00\x00\xba\x03\x00\x00\x58\x06\xad\x03\x00\x00\x00\x00\x00\x00\x27\x00\x25\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\xd7\x02\x00\x00\x00\x00\x00\x00\x85\x00\xd3\x02\xdb\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf3\xff\x00\x00\x00\x00\x00\x00\x00\x00\xe7\xff\x00\x00\x00\x00\x00\x00\xc0\x00\xb6\x05\x00\x00\x00\x00\x00\x00\xba\x08\x2a\x03\x00\x00\x00\x00\x00\x00\x1f\x03\x00\x00\x00\x00\x32\x03\x95\x02\x00\x00\xaa\xff\x06\x03\x08\x03\x00\x00\x00\x00\xa7\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\xd2\x22\x00\x00\x00\x00\x00\x00\x54\x2c\x00\x00\x20\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0d\x27\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\x00\x00\x00\x00\x06\x2c\x00\x00\xd4\x00\x00\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0\x2b\x00\x00\x00\x00\x36\x22\xe8\x21\xa6\x24\x00\x00\x00\x00\x00\x00\xc3\x02\x00\x00\xb8\x19\x00\x00\x00\x00\x60\x2a\x00\x00\x75\x02\xb8\x02\x00\x00\x00\x00\x00\x00\x58\x03\x00\x00\x00\x00\x00\x00\xbb\x02\x00\x00\x00\x00\x00\x00\xab\x04\x3c\x00\x23\x00\x00\x00\x00\x00\xab\x02\x31\x00\x00\x00\xd1\x01\xce\x08\x00\x00\x00\x00\xa7\x06\x82\xff\x00\x00\x00\x00\xf8\x03\x1a\x09\x00\x00\x24\x03\x00\x00\x00\x00\x38\x02\x00\x00\xf5\x26\xa7\x26\x00\x00\x00\x00\x00\x00\x00\x00\xb9\x03\x5d\x00\x1e\x00\x69\x01\x00\x00\x02\x03\x01\x03\x00\x00\x3c\x02\x8f\x26\xdf\x00\x00\x00\x12\x17\xb5\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd0\xff\x00\x00\x6f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf7\xff\x00\x00\x00\x00\x00\x00\x44\x03\x00\x00\x00\x00\xea\x02\x00\x00\xdc\x02\x00\x00\x7b\x00\x00\x00\x61\x02\x00\x00\x00\x00\xd4\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x02\x00\x00\x00\x00\x00\x00\x41\x26\x00\x00\x00\x00\x00\x00\x00\x00\x69\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x05\x00\x00\x12\x03\x00\x00\x00\x00\x00\x00\x58\x06\x00\x00\x3f\x02\x74\xff\x00\x00\x00\x00\x21\x02\x00\x00\xf6\x01\x00\x00\xd6\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x02\x5d\x04\xf5\x01\x00\x00\x00\x00\x15\x09\x00\x00\xd1\x01\x00\x00\x9b\x00\x09\x09\x00\x00\x00\x00\x00\x00\x00\x00\x19\x01\x00\x00\xc5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x02\x00\x00\xfe\x02\x00\x00\xf1\xff\x00\x00\x00\x00\x00\x00\x29\x26\xdb\x25\xc3\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x02\xe2\x01\x00\x00\x84\x22\x75\x25\x76\x2a\x00\x00\xa2\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x77\x02\x00\x00\x00\x00\x2a\x00\x00\x00\x00\x00\xd1\x01\x00\x00\x00\x00\xd1\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x09\x00\x00\x00\x00\x00\x00\x00\x00\x8a\x00\x00\x00\x00\x00\xc5\x06\x62\x01\x00\x00\x00\x00\x73\x05\x19\x03\x00\x00\x44\x01\x00\x00\x5e\x05\x00\x00\x00\x00\x5c\x00\x00\x00\x11\x00\x00\x00\xb6\xff\x00\x00\x00\x00\x00\x00\x5c\x02\x00\x00\x85\x01\x00\x00\xfb\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe3\x01\x9a\x01\x00\x00\x00\x00\x17\x05\x00\x00\x00\x00\x0f\x01\xf7\x00\x9d\x02\x00\x00\x00\x00\x00\x00\xbd\x00\x68\x04\xf8\x08\xf3\x08\x03\x05\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xed\x02\x5d\x25\x00\x00\x00\x00\x0f\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe2\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\x04\x00\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\xef\xff\x00\x00\xb4\x00\x57\x02\xa7\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x2b\x00\x00\x00\x00\x00\x00\x9f\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfd\xff\x00\x00\x00\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4e\x00\x00\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#++happyDefActions :: HappyAddr+happyDefActions = HappyA# "\x98\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\xfd\x98\xfd\x00\x00\xe5\xff\xed\xff\x00\x00\x00\x00\xf9\xfd\xc0\xfe\xbe\xfe\xb8\xfe\xb7\xfe\xb5\xfe\xb3\xfe\xae\xfe\xa5\xfe\xa0\xfe\x98\xfe\x94\xfe\x82\xfe\x00\x00\x00\x00\x91\xfe\x92\xfe\x93\xfe\xe9\xfd\xe4\xfd\xbe\xfd\xcb\xfd\xe2\xfd\xdf\xfd\xb6\xfd\x90\xfe\xc9\xfd\xca\xfd\xb8\xfd\xb7\xfd\xb4\xfd\xb5\xfd\xa2\xfd\xa0\xfd\xa1\xfd\x9f\xfd\x9e\xfd\x9d\xfd\x9c\xfd\x9b\xfd\x9a\xfd\x99\xfd\x00\x00\x00\x00\x00\x00\x86\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x98\xfd\x00\x00\x00\x00\x77\xfe\x00\x00\x00\x00\x62\xfe\xc5\xfd\xbd\xfd\xbc\xfd\xbb\xfd\xc4\xfd\xc3\xfd\xc2\xfd\xc1\xfd\xc0\xfd\xbf\xfd\xc8\xfd\x00\x00\x98\xfd\xb9\xfd\xba\xfd\xc6\xfd\x00\x00\x98\xfd\x98\xfd\x00\x00\x98\xfd\xc7\xfd\x00\x00\x00\x00\x00\x00\x41\xff\x27\xff\x48\xff\x3e\xff\x3c\xff\x35\xff\x00\x00\x2a\xff\x00\x00\x00\x00\x90\xfd\x2e\xff\x3b\xff\x91\xfd\x00\x00\x00\x00\x00\x00\x8f\xfd\x8e\xfd\x8d\xfd\x20\xff\x85\xff\xad\xff\x00\x00\x00\x00\x90\xff\x86\xff\x7f\xff\x84\xff\x97\xff\xb7\xfe\x00\x00\x00\x00\x00\x00\x8f\xff\x00\x00\x00\x00\xab\xff\xaa\xff\xa9\xff\x00\x00\x98\xfd\x8e\xff\x00\x00\x5e\xff\x5e\xff\x5e\xff\x5e\xff\x60\xff\x52\xff\x52\xff\x00\x00\x04\xfe\x00\x00\x00\x00\xc0\xfe\x00\x00\xe5\xff\xf4\xff\xf2\xff\x98\xfd\x00\x00\xe5\xff\x00\x00\x00\x00\x00\x00\x4d\xff\x4e\xff\xe8\xfd\xe1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x53\xff\x00\x00\x50\xff\x00\x00\x00\x00\x61\xff\x5e\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\xff\x00\x00\x00\x00\x76\xff\x00\x00\xd9\xff\xd9\xff\xd6\xfe\x00\x00\x8b\xff\x00\x00\x1a\xff\x00\x00\x00\x00\x00\x00\x00\x00\xd1\xfd\xd0\xfd\x00\x00\xd5\xfd\xcc\xfd\xb3\xfd\xdb\xfd\xb0\xfd\xaf\xfd\xac\xfd\xb1\xfd\xa3\xfd\xb2\xfd\x00\x00\x00\x00\xa9\xfd\xcd\xfd\x00\x00\xab\xfd\xaa\xfd\xa8\xfd\xe6\xfe\x00\x00\x00\x00\xac\xff\x00\x00\x00\x00\x32\xff\x23\xff\x00\x00\x00\x00\x30\xff\x75\xfe\x23\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x34\xff\x00\x00\x00\x00\x28\xff\x3f\xff\x00\x00\x2b\xff\x00\x00\x8b\xfd\x8a\xfd\x00\x00\x00\x00\x00\x00\x26\xff\x00\x00\x00\x00\x00\x00\xf8\xfd\xfe\xfd\xfe\xfd\x00\x00\x9d\xfe\x00\x00\xa6\xfe\xfb\xfd\xac\xfe\xa7\xfe\x00\x00\xaa\xfe\x00\x00\x2c\xfe\x5d\xfe\x59\xfe\x5c\xfe\x5b\xfe\x5a\xfe\x55\xfe\x54\xfe\x53\xfe\x52\xfe\x51\xfe\x50\xfe\x4f\xfe\x4e\xfe\x4d\xfe\x4c\xfe\x4b\xfe\x4a\xfe\x49\xfe\x48\xfe\x57\xfe\x56\xfe\x47\xfe\x46\xfe\x45\xfe\x44\xfe\x43\xfe\x42\xfe\x41\xfe\x40\xfe\x3f\xfe\x3e\xfe\x3d\xfe\x3c\xfe\x3b\xfe\x3a\xfe\x39\xfe\x38\xfe\x37\xfe\x36\xfe\x35\xfe\x34\xfe\x33\xfe\x32\xfe\x31\xfe\x58\xfe\x30\xfe\x2f\xfe\x2e\xfe\x78\xfe\x79\xfe\x00\x00\x00\x00\x00\x00\x7b\xfe\x7a\xfe\x00\x00\x00\x00\x00\x00\x00\x00\xb7\xfe\x00\x00\x00\x00\x6a\xfe\x00\x00\x03\xfe\xa8\xfe\x99\xfe\x00\x00\x9e\xfe\x74\xfe\x28\xfe\x00\x00\x27\xfe\xcf\xfd\xce\xfd\x00\x00\xd9\xfd\xae\xfd\xad\xfd\xa7\xfd\xed\xfd\x00\x00\xa5\xfd\xa6\xfd\xa4\xfd\x00\x00\x00\x00\xeb\xfd\x74\xfe\x00\x00\x00\x00\x00\x00\xd5\xfd\x00\x00\xad\xfd\xa7\xfd\xee\xfd\xa5\xfd\xab\xfd\xa6\xfd\xa4\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\xfe\xbd\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd9\xff\x00\x00\x00\x00\xf7\xff\xe5\xff\xf6\xff\x00\x00\xd9\xff\xe8\xff\xda\xff\x00\x00\xed\xff\xef\xff\x96\xfd\x97\xfd\xb9\xfe\xba\xfe\xbb\xfe\xbc\xfe\xbf\xfe\xb6\xfe\xb4\xfe\x00\x00\xf6\xfd\xf4\xfd\x00\x00\x97\xfe\xf3\xfd\xfa\xfd\x9a\xfe\x9b\xfe\x00\x00\x43\xff\xe3\xfd\xde\xfd\x85\xfe\x00\x00\x8e\xfe\x8f\xfe\x00\x00\xec\xfd\x76\xfe\x00\x00\x00\x00\x00\x00\x8b\xfe\x8a\xfe\x00\x00\xea\xfd\x00\x00\x00\x00\x73\xfe\x00\x00\x87\xfe\x00\x00\x26\xfe\x00\x00\x9f\xfe\x00\x00\x00\x00\x84\xfe\x00\x00\x80\xfe\x7f\xfe\x7e\xfe\x7d\xfe\x00\x00\xd9\xff\xa4\xff\x00\x00\x00\x00\x29\xfe\x65\xfe\x00\x00\x5f\xfe\x63\xfe\xab\xfe\x61\xfe\x00\x00\x98\xfd\x00\x00\xad\xfe\x00\x00\x9c\xfe\x00\x00\x00\x00\xfc\xfd\xfe\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x44\xff\x45\xff\x00\x00\x46\xff\x47\xff\x42\xff\x33\xff\x2c\xff\x2d\xff\x31\xff\x00\x00\x3a\xff\x37\xff\x00\x00\x2f\xff\x39\xff\x00\x00\x38\xff\x21\xff\x1f\xff\x00\x00\x00\x00\xae\xff\xd3\xfd\xd2\xfd\xa7\xff\xd7\xfd\xdd\xfd\x00\x00\xe6\xfe\xf2\xfe\x13\xff\x00\x00\x08\xff\x81\xff\x00\x00\x00\x00\x72\xff\xc8\xfe\xc4\xfe\xc2\xfe\x00\x00\x00\x00\xc8\xfe\x66\xff\x71\xff\x70\xff\x6f\xff\x6e\xff\x6d\xff\x6c\xff\x6b\xff\x00\x00\xe2\xfe\x1c\xff\xe6\xfe\x00\x00\x8c\xff\x43\xff\x8d\xff\x99\xff\x9a\xff\x98\xfd\x89\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\xff\xe6\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\xff\x62\xff\x94\xff\x54\xff\x93\xff\x00\x00\x51\xff\x92\xff\x00\x00\x4b\xff\x00\x00\x00\x00\x91\xff\x4a\xff\xe2\xff\x95\xfd\x94\xfd\x00\x00\x2c\xfe\xe7\xff\xd9\xff\xd9\xff\x00\x00\xdc\xff\x00\x00\x29\xfe\x00\x00\xd7\xff\x00\x00\x00\x00\xe7\xfd\xe0\xfd\x4c\xff\x4f\xff\x55\xff\x63\xff\x00\x00\x00\x00\x00\x00\x00\x00\x5d\xff\x00\x00\x7a\xff\x7d\xff\x7e\xff\xa3\xff\x44\xff\xa2\xff\x00\x00\x74\xff\x82\xff\x75\xff\x83\xff\xd9\xff\x87\xff\xc6\xfe\xd9\xff\xf0\xfd\x93\xfe\xdb\xff\xd9\xff\xd9\xff\x98\xff\x9e\xff\x00\x00\x19\xff\x17\xff\x9b\xff\x98\xfd\x95\xff\x00\x00\xe6\xfd\x00\x00\x00\x00\x00\x00\x6a\xff\x69\xff\x68\xff\x67\xff\xca\xfe\x98\xfd\x11\xfe\x00\x00\x13\xfe\x00\x00\x98\xfd\xc5\xfe\xc3\xfe\xcb\xfe\x00\x00\x00\x00\xda\xfd\x0e\xff\x0c\xff\x00\x00\x20\xff\xe5\xfe\xec\xfe\xeb\xfe\x00\x00\xe8\xfe\xe9\xfe\xf2\xfe\x98\xfd\xa0\xff\x00\x00\xf2\xfe\x13\xff\x00\x00\x00\x00\x00\x00\x29\xff\x00\x00\x22\xff\x00\x00\x24\xff\x8c\xfd\x25\xff\x00\x00\xa3\xfe\xa4\xfe\x01\xfe\xff\xfd\x00\xfe\xfe\xfd\x02\xfe\xaf\xfe\xb1\xfe\x00\x00\xa9\xfe\xd9\xff\xd9\xff\x6a\xfe\x00\x00\x00\x00\x2a\xfe\x00\x00\x2d\xfe\x00\x00\xc9\xfd\xb4\xfd\xc5\xfd\xbd\xfd\xbc\xfd\xbb\xfd\xc4\xfd\xc3\xfd\xc2\xfd\xc1\xfd\xc0\xfd\xbf\xfd\xc8\xfd\xb9\xfd\xba\xfd\xc6\xfd\xc7\xfd\x5e\xfe\xda\xff\xa6\xff\x00\x00\x00\x00\x6b\xfe\xb2\xfe\x22\xfe\x1e\xfe\x1c\xfe\x1b\xfe\x1a\xfe\x00\x00\x24\xfe\x74\xfe\x20\xfe\x21\xfe\xd4\xfd\xd8\xfd\x88\xfe\x89\xfe\x00\x00\x6c\xfe\x72\xfe\x68\xfe\x69\xfe\x8c\xfe\x8d\xfe\x00\x00\x6f\xfe\x95\xfe\x00\x00\x96\xfe\x00\x00\xee\xff\xeb\xff\x00\x00\x00\x00\xea\xff\xec\xff\xe9\xff\xf7\xfd\xf5\xfd\x71\xfe\x70\xfe\x6e\xfe\x6d\xfe\x25\xfe\x19\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x83\xfe\x7c\xfe\xa5\xff\x62\xfe\x66\xfe\x00\x00\x64\xfe\x60\xfe\x00\x00\x00\x00\x00\x00\xac\xfe\xfd\xfd\x00\x00\x36\xff\x00\x00\xa8\xff\xd6\xfd\xdc\xfd\xf2\xfe\x9d\xff\xf1\xfe\xed\xfe\x00\x00\xd9\xff\xd9\xff\x9f\xff\x00\x00\x00\x00\x00\x00\xfb\xfe\x03\xff\x00\x00\x0a\xff\x07\xff\x02\xff\x00\x00\x00\x00\x2e\xff\x00\x00\x00\x00\x00\x00\x08\xff\x80\xff\x73\xff\x00\x00\x10\xfe\x00\x00\x00\x00\xc9\xfe\x96\xff\x00\x00\x00\x00\x00\x00\xd9\xff\xd9\xff\x1c\xff\x1d\xff\x1c\xff\xd4\xfe\x00\x00\x00\x00\x00\x00\xda\xff\xf2\xfd\x00\x00\xda\xff\x8a\xff\xa1\xff\x00\x00\x79\xff\x77\xff\x5c\xff\x00\x00\x00\x00\x59\xff\x57\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\xff\xd3\xff\xf3\xff\x00\x00\xe0\xff\xd9\xff\xc9\xff\xde\xff\xc6\xff\xe1\xff\xc4\xff\x00\x00\xda\xff\xdd\xff\x62\xfe\xf0\xff\x00\x00\xd3\xff\xd1\xff\xd0\xff\x92\xfd\xcf\xff\xd4\xff\x00\x00\xe6\xff\xe4\xff\xe3\xff\x00\x00\x00\x00\x58\xff\x5a\xff\x7b\xff\x00\x00\x7c\xff\x88\xff\xf1\xfd\x00\x00\xef\xfd\xd7\xfe\xd8\xfe\x00\x00\xcf\xfe\xd9\xff\xd2\xfe\xd0\xfe\xd1\xfe\xc6\xfe\x8f\xff\x00\x00\x00\x00\x16\xff\x18\xff\xe0\xfe\x00\x00\x00\x00\x64\xff\x00\x00\xe5\xfd\xc1\xfe\x12\xfe\x0d\xff\x00\x00\xfa\xfe\x3d\xff\x00\x00\x00\x00\x00\x00\x00\x00\xfe\xfe\xff\xfe\x00\x00\x00\x00\x03\xff\x0b\xff\x00\x00\x00\x00\x00\x00\x09\xff\xea\xfe\xe7\xfe\x00\x00\x00\x00\x00\x00\xee\xfe\x00\x00\xf0\xfe\x9c\xff\x00\x00\x00\x00\x00\x00\x0e\xfe\x0f\xfe\xd9\xff\x0b\xfe\x00\x00\x2b\xfe\xaa\xfe\x14\xfe\x1f\xfe\x1d\xfe\x00\x00\x00\x00\x00\x00\x23\xfe\x18\xfe\x16\xfe\x17\xfe\x00\x00\xc8\xfe\x08\xfe\x06\xfe\x00\x00\x00\x00\xda\xff\x0d\xfe\x00\x00\x00\x00\x1e\xff\xef\xfe\x14\xff\x15\xff\xd9\xff\x10\xff\x00\x00\x00\x00\x00\x00\x01\xff\x00\x00\x00\x00\xfd\xfe\x40\xff\x06\xff\x00\x00\x00\x00\xf7\xfe\x05\xff\x2d\xff\x00\x00\x65\xff\xe3\xfe\xe4\xfe\xdd\xfe\xd9\xff\xde\xfe\xdc\xfe\x00\x00\x00\x00\x1b\xff\x00\x00\x00\x00\xda\xff\xd5\xfe\xe6\xfe\x78\xff\x00\x00\x5f\xff\xcb\xff\x00\x00\x00\x00\xd4\xff\xd5\xff\x00\x00\xca\xff\xdf\xff\xc7\xff\xc2\xff\xc5\xff\x00\x00\xc3\xff\x00\x00\xd2\xff\xd6\xff\x00\x00\xb1\xff\xb0\xff\xaf\xff\xcd\xff\x00\x00\x00\x00\xf2\xfe\x13\xff\xd3\xfe\xc7\xfe\x00\x00\x00\x00\x41\xff\xe6\xfe\xe6\xfe\xda\xff\xe1\xfe\xf9\xfe\x04\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xda\xff\x12\xff\x00\x00\xb0\xfe\x0c\xfe\x09\xfe\x00\x00\x07\xfe\x0a\xfe\x00\x00\x00\x00\x15\xfe\x00\x00\x00\x00\x00\x00\x11\xff\x0f\xff\x00\xff\xfc\xfe\xf5\xfe\xf6\xfe\x00\x00\x00\x00\xf8\xfe\xdf\xfe\xd9\xfe\xdb\xfe\x00\x00\xce\xfe\xf2\xfe\xcd\xfe\x56\xff\xce\xff\xcc\xff\x00\x00\x00\x00\xc0\xff\xbe\xff\x00\x00\xf1\xff\xb2\xff\xcc\xfe\xda\xfe\x00\x00\xf4\xfe\x00\x00\x05\xfe\x67\xfe\xa2\xfe\x00\x00\xc1\xff\xc8\xff\xbf\xff\x00\x00\xbb\xff\xd3\xff\xf3\xfe\x00\x00\xd3\xff\xb8\xff\xb7\xff\x93\xfd\xb6\xff\x00\x00\x00\x00\xd4\xff\xbc\xff\xb9\xff\xbd\xff\x00\x00\xb4\xff\x00\x00\xb5\xff\xb3\xff"#++happyCheck :: HappyAddr+happyCheck = HappyA# "\xff\xff\x00\x00\x04\x00\x04\x00\x02\x00\x04\x00\x04\x00\x0b\x00\x11\x00\x12\x00\x13\x00\x3b\x00\x3c\x00\x07\x00\x11\x00\x20\x00\x24\x00\x36\x00\x0d\x00\x0e\x00\x2d\x00\x6b\x00\x07\x00\x3b\x00\x3c\x00\x32\x00\x1d\x00\x1e\x00\x90\x00\x0d\x00\x0e\x00\x1c\x00\x2d\x00\x16\x00\x2d\x00\x1c\x00\x13\x00\x32\x00\xa7\x00\x32\x00\x0d\x00\x0e\x00\x22\x00\x0d\x00\x0e\x00\x0d\x00\x0e\x00\x36\x00\x0d\x00\x0e\x00\x0d\x00\x0e\x00\x0d\x00\x0e\x00\x20\x00\x2d\x00\x1c\x00\x09\x00\x2a\x00\x0b\x00\x32\x00\xc9\x00\x11\x00\xaf\x00\x1c\x00\xaf\x00\x1c\x00\x5d\x00\xc2\x00\x2a\x00\x08\x00\x09\x00\x1c\x00\x0d\x00\x0e\x00\xaf\x00\x96\x00\x00\x00\x98\x00\xdb\x00\xdc\x00\xcf\x00\x46\x00\xc7\x00\x48\x00\xd6\x00\x4e\x00\x27\x00\x08\x00\x09\x00\xce\x00\xcf\x00\xd0\x00\x0c\x00\xd2\x00\x79\x00\xd4\x00\x45\x00\x46\x00\x25\x00\x48\x00\x49\x00\xd6\x00\x1e\x00\xd6\x00\x4d\x00\x0d\x00\x0e\x00\x1f\x00\x1f\x00\x20\x00\x31\x00\x32\x00\x33\x00\xd6\x00\x68\x00\x24\x00\x25\x00\xcc\x00\xcd\x00\x87\x00\x14\x00\x15\x00\x1f\x00\x20\x00\x5a\x00\x72\x00\xd8\x00\x2f\x00\x31\x00\x32\x00\x33\x00\x53\x00\x6f\x00\x21\x00\x96\x00\x23\x00\x98\x00\x25\x00\x26\x00\x27\x00\x28\x00\x8b\x00\x71\x00\x15\x00\x2c\x00\x8b\x00\x2e\x00\x2f\x00\xba\x00\x5a\x00\x0d\x00\x0e\x00\xc9\x00\xca\x00\x76\x00\x21\x00\x76\x00\x23\x00\x5c\x00\x25\x00\x26\x00\x27\x00\x28\x00\xc9\x00\xc9\x00\xca\x00\x2c\x00\xb9\x00\x2e\x00\x2f\x00\xbf\x00\xbd\x00\xa8\x00\xc2\x00\x8b\x00\xc4\x00\x8b\x00\xbb\x00\xba\x00\x33\x00\xbe\x00\xb9\x00\x8b\x00\xc9\x00\xca\x00\xbd\x00\xcf\x00\xcd\x00\xd6\x00\xd2\x00\xc8\x00\xc9\x00\xca\x00\xc9\x00\xcc\x00\xcd\x00\xb5\x00\xc9\x00\xca\x00\xa8\x00\xd6\x00\xcd\x00\xd6\x00\xbb\x00\x19\x00\x71\x00\xbe\x00\xb5\x00\xda\x00\xd6\x00\xcd\x00\xd6\x00\xd6\x00\xd9\x00\xd6\x00\xd6\x00\xc8\x00\xc9\x00\xca\x00\xcd\x00\xcc\x00\xcd\x00\x7a\x00\xd6\x00\x09\x00\x47\x00\x19\x00\x49\x00\x4a\x00\x4b\x00\x82\x00\x83\x00\x84\x00\x85\x00\xda\x00\x22\x00\x88\x00\x89\x00\x8a\x00\x33\x00\xc7\x00\x8d\x00\x8e\x00\x8f\x00\x7a\x00\x40\x00\x41\x00\xce\x00\xcf\x00\xc9\x00\x96\x00\x24\x00\x82\x00\x83\x00\x84\x00\x85\x00\xbe\x00\xb9\x00\x88\x00\x89\x00\x8a\x00\xbd\x00\xb9\x00\x8d\x00\x8e\x00\x8f\x00\xbd\x00\xdb\x00\xdc\x00\x16\x00\xcc\x00\xcd\x00\x96\x00\xc9\x00\xca\x00\x1a\x00\xb9\x00\xcd\x00\xc9\x00\xca\x00\xbd\x00\x69\x00\xcd\x00\x90\x00\xb8\x00\x72\x00\x93\x00\xbb\x00\xbc\x00\xd9\x00\xbe\x00\x67\x00\xc9\x00\xca\x00\x50\x00\x2e\x00\xcd\x00\x32\x00\x33\x00\x87\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xb8\x00\x3a\x00\x22\x00\xbb\x00\xbc\x00\x8c\x00\xbe\x00\xd5\x00\x96\x00\xbb\x00\x98\x00\x22\x00\xba\x00\x90\x00\x6a\x00\x92\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xc8\x00\xc9\x00\xca\x00\x39\x00\x21\x00\xc9\x00\x23\x00\xd5\x00\x25\x00\x26\x00\x27\x00\x28\x00\x39\x00\xb3\x00\xb4\x00\x2c\x00\x43\x00\x2e\x00\x2f\x00\x22\x00\x47\x00\xbb\x00\x49\x00\x4a\x00\x4b\x00\x28\x00\x21\x00\xc9\x00\x23\x00\x6f\x00\xcc\x00\xcd\x00\x27\x00\x28\x00\xc8\x00\xc9\x00\xca\x00\x2c\x00\xb9\x00\x2e\x00\x2f\x00\x29\x00\xbd\x00\x5b\x00\x5c\x00\xdb\x00\xdc\x00\xbb\x00\xb9\x00\x05\x00\x06\x00\x03\x00\x26\x00\x6f\x00\xc9\x00\xca\x00\x08\x00\x09\x00\xcd\x00\x2d\x00\xc8\x00\xc9\x00\xca\x00\xb4\x00\xc9\x00\xca\x00\x16\x00\x43\x00\x44\x00\x45\x00\xbb\x00\x47\x00\x1c\x00\x49\x00\x4a\x00\x4b\x00\x08\x00\xb7\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\xbc\x00\xc8\x00\xc9\x00\xca\x00\x22\x00\x90\x00\x5d\x00\x92\x00\x26\x00\x42\x00\x43\x00\x7a\x00\x45\x00\x2b\x00\x47\x00\xcb\x00\x49\x00\x4a\x00\x4b\x00\x82\x00\x83\x00\x84\x00\x85\x00\x25\x00\x6f\x00\x88\x00\x89\x00\x8a\x00\x17\x00\x17\x00\x8d\x00\x8e\x00\x8f\x00\x7a\x00\x54\x00\x31\x00\x32\x00\x33\x00\x58\x00\x96\x00\x22\x00\x82\x00\x83\x00\x84\x00\x85\x00\x28\x00\xc9\x00\x88\x00\x89\x00\x8a\x00\x3f\x00\x40\x00\x8d\x00\x8e\x00\x8f\x00\xd0\x00\x21\x00\xd2\x00\x23\x00\xd4\x00\xbe\x00\x96\x00\x27\x00\x28\x00\xdb\x00\xdc\x00\xc9\x00\x2c\x00\xc9\x00\x2e\x00\x2f\x00\xcc\x00\xcd\x00\xb8\x00\xcc\x00\xcd\x00\xbb\x00\xbc\x00\xc9\x00\xbe\x00\x90\x00\xcc\x00\xcd\x00\x93\x00\xdb\x00\xdc\x00\xdb\x00\xdc\x00\x59\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xb8\x00\xdb\x00\xdc\x00\xbb\x00\xbc\x00\x5d\x00\xbe\x00\xd5\x00\x05\x00\x06\x00\x54\x00\xbc\x00\x90\x00\x57\x00\x58\x00\x93\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\x5d\x00\x6f\x00\xc9\x00\x16\x00\xcb\x00\xcc\x00\xcd\x00\xd5\x00\x42\x00\x43\x00\x49\x00\x4a\x00\x4b\x00\x47\x00\xbc\x00\x49\x00\x4a\x00\x4b\x00\x6f\x00\x22\x00\xdb\x00\xdc\x00\x22\x00\x19\x00\x08\x00\x28\x00\x0a\x00\xc9\x00\x7a\x00\xcb\x00\xcc\x00\xcd\x00\x22\x00\x2d\x00\x05\x00\x06\x00\x82\x00\x83\x00\x84\x00\x85\x00\xc9\x00\xca\x00\x88\x00\x89\x00\x8a\x00\xdb\x00\xdc\x00\x8d\x00\x8e\x00\x8f\x00\x21\x00\x16\x00\x23\x00\x25\x00\xcf\x00\xb9\x00\x96\x00\xd2\x00\x17\x00\xbd\x00\x69\x00\x2c\x00\x17\x00\x2e\x00\x2f\x00\x31\x00\x32\x00\x33\x00\xbb\x00\x22\x00\x19\x00\xc9\x00\xca\x00\x22\x00\x21\x00\xcd\x00\x23\x00\xd8\x00\x90\x00\x22\x00\x92\x00\xc8\x00\xc9\x00\xca\x00\x2b\x00\x2c\x00\xbf\x00\x2e\x00\x2f\x00\xc2\x00\xb8\x00\xc4\x00\x17\x00\xbb\x00\xbc\x00\x19\x00\xbe\x00\x1a\x00\x1b\x00\x1c\x00\x18\x00\x17\x00\xcf\x00\x22\x00\x22\x00\xd2\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\x22\x00\x42\x00\x43\x00\xbb\x00\x0d\x00\x0e\x00\x47\x00\xd5\x00\x49\x00\x4a\x00\x4b\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\xad\x00\xc8\x00\xc9\x00\xca\x00\x72\x00\x73\x00\x74\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xc9\x00\x7a\x00\xd7\x00\xcc\x00\xcd\x00\xc9\x00\x33\x00\x7b\x00\xcc\x00\xcd\x00\x2b\x00\x84\x00\x2d\x00\x24\x00\x25\x00\x88\x00\x27\x00\x8a\x00\xdb\x00\xdc\x00\x8d\x00\x8e\x00\x8f\x00\xdb\x00\xdc\x00\x7a\x00\x31\x00\x32\x00\x33\x00\x96\x00\x22\x00\x17\x00\x0d\x00\x0e\x00\x19\x00\x84\x00\x21\x00\x29\x00\x23\x00\x88\x00\xcd\x00\x8a\x00\x22\x00\x22\x00\x8d\x00\x8e\x00\x8f\x00\x2c\x00\x43\x00\x2e\x00\x2f\x00\xd7\x00\x47\x00\x96\x00\x49\x00\x4a\x00\x4b\x00\x66\x00\x67\x00\x19\x00\x21\x00\x1e\x00\x23\x00\xb8\x00\xd8\x00\x22\x00\xbb\x00\xbc\x00\x22\x00\xbe\x00\x01\x00\x2c\x00\x1e\x00\x2e\x00\x2f\x00\x11\x00\x22\x00\x08\x00\x09\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xb6\x00\xb7\x00\xb8\x00\xc7\x00\x17\x00\xbb\x00\xbc\x00\xd5\x00\xbe\x00\x97\x00\xce\x00\xcf\x00\xd0\x00\x27\x00\xd2\x00\x29\x00\xd4\x00\x16\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\x27\x00\xc9\x00\x29\x00\xd2\x00\xcc\x00\xcd\x00\x01\x00\xd5\x00\xbb\x00\x73\x00\x74\x00\xb9\x00\xd7\x00\x08\x00\x09\x00\xbd\x00\x7a\x00\x6d\x00\x6e\x00\xdb\x00\xdc\x00\xc8\x00\xc9\x00\xca\x00\x0d\x00\x0e\x00\x84\x00\xc9\x00\xca\x00\x69\x00\x88\x00\xcd\x00\x8a\x00\xbb\x00\x28\x00\x8d\x00\x8e\x00\x8f\x00\xc9\x00\xca\x00\x7a\x00\x2f\x00\xcd\x00\x27\x00\x96\x00\x29\x00\xc8\x00\xc9\x00\xca\x00\xbb\x00\x84\x00\x27\x00\xbe\x00\x29\x00\x88\x00\x86\x00\x8a\x00\xbb\x00\x28\x00\x8d\x00\x8e\x00\x8f\x00\xc8\x00\xc9\x00\xca\x00\x2f\x00\xcc\x00\xcd\x00\x96\x00\xd7\x00\xc8\x00\xc9\x00\xca\x00\xc9\x00\x0d\x00\x0e\x00\xcc\x00\xcd\x00\xb8\x00\x54\x00\x55\x00\xbb\x00\xbc\x00\x97\x00\xbe\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x59\x00\xdb\x00\xdc\x00\x4d\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xd6\x00\x27\x00\xb8\x00\x29\x00\x69\x00\xbb\x00\xbc\x00\xd5\x00\xbe\x00\x51\x00\x52\x00\x53\x00\x54\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x52\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\x5f\x00\x60\x00\x84\x00\x99\x00\x9a\x00\x9b\x00\x88\x00\xd5\x00\x8a\x00\x6d\x00\x6e\x00\x8d\x00\x8e\x00\x8f\x00\x78\x00\x79\x00\x7a\x00\x99\x00\x9a\x00\x9b\x00\x96\x00\x43\x00\x30\x00\x31\x00\x69\x00\x47\x00\x84\x00\x49\x00\x4a\x00\x4b\x00\x88\x00\x27\x00\x8a\x00\x29\x00\xd2\x00\x8d\x00\x8e\x00\x8f\x00\xab\x00\xac\x00\xad\x00\x43\x00\xd6\x00\x45\x00\x96\x00\x47\x00\x03\x00\x49\x00\x4a\x00\x4b\x00\x0f\x00\x10\x00\x4e\x00\x4f\x00\xb8\x00\x0d\x00\x0e\x00\xbb\x00\xbc\x00\xd7\x00\xbe\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x6c\x00\x6d\x00\x6e\x00\x0d\x00\x0e\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\x9c\x00\x27\x00\xb8\x00\x29\x00\x0a\x00\xbb\x00\xbc\x00\xd5\x00\xbe\x00\x30\x00\x31\x00\x3e\x00\x3f\x00\x40\x00\x38\x00\x0c\x00\x0d\x00\x0e\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x43\x00\x3a\x00\x45\x00\xd5\x00\x47\x00\x6f\x00\x49\x00\x4a\x00\x4b\x00\x30\x00\x31\x00\x4e\x00\x4f\x00\x0c\x00\x0d\x00\x0e\x00\x42\x00\x43\x00\x6c\x00\x6d\x00\x6e\x00\x47\x00\xd6\x00\x49\x00\x4a\x00\x4b\x00\xd7\x00\x27\x00\x43\x00\x29\x00\x45\x00\x29\x00\x47\x00\x2b\x00\x49\x00\x4a\x00\x4b\x00\x42\x00\x43\x00\x4e\x00\x4f\x00\x27\x00\x47\x00\x29\x00\x49\x00\x4a\x00\x4b\x00\xd7\x00\xc8\x00\xc9\x00\xca\x00\xc9\x00\xcc\x00\xcd\x00\xcc\x00\xcd\x00\x9a\x00\x9b\x00\xbc\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5e\x00\x5f\x00\x60\x00\xdb\x00\xdc\x00\xc9\x00\x70\x00\xcb\x00\xcc\x00\xcd\x00\x6c\x00\x6d\x00\x6e\x00\x35\x00\x43\x00\xb9\x00\x45\x00\x7f\x00\x47\x00\xbd\x00\x49\x00\x4a\x00\x4b\x00\xdb\x00\xdc\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x0d\x00\x0e\x00\xc9\x00\xca\x00\x0d\x00\x0e\x00\xcd\x00\x7d\x00\x7e\x00\x7f\x00\x43\x00\xb9\x00\x45\x00\x6f\x00\x47\x00\xbd\x00\x49\x00\x4a\x00\x4b\x00\x0d\x00\x0e\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x59\x00\xbc\x00\xc9\x00\xca\x00\x69\x00\xc9\x00\xcd\x00\x7b\x00\xcc\x00\xcd\x00\x7b\x00\x40\x00\x41\x00\x27\x00\xc9\x00\x29\x00\xcb\x00\xcc\x00\xcd\x00\x7d\x00\x7e\x00\x7f\x00\xd7\x00\xdb\x00\xdc\x00\x99\x00\x9a\x00\x9b\x00\x27\x00\xbc\x00\x29\x00\xc9\x00\xdb\x00\xdc\x00\xcc\x00\xcd\x00\x27\x00\x90\x00\x29\x00\x99\x00\x9a\x00\x9b\x00\xc9\x00\xb1\x00\xcb\x00\xcc\x00\xcd\x00\x05\x00\x06\x00\xdb\x00\xdc\x00\x27\x00\xc9\x00\x29\x00\xd7\x00\xcc\x00\xcd\x00\x88\x00\x89\x00\x8a\x00\xdb\x00\xdc\x00\x90\x00\x90\x00\x46\x00\x47\x00\x9c\x00\x49\x00\x4a\x00\x4b\x00\xdb\x00\xdc\x00\x43\x00\x27\x00\x45\x00\x29\x00\x47\x00\xd7\x00\x49\x00\x4a\x00\x4b\x00\xbc\x00\x4d\x00\x4e\x00\x4f\x00\xc8\x00\xc9\x00\xca\x00\x86\x00\xcc\x00\xcd\x00\x27\x00\xc7\x00\x29\x00\xc9\x00\x65\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\x27\x00\xd2\x00\x29\x00\xd4\x00\xbc\x00\x34\x00\x27\x00\x68\x00\x29\x00\x34\x00\xdb\x00\xdc\x00\x2b\x00\x56\x00\x2d\x00\xc7\x00\x29\x00\xc9\x00\x2b\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\x75\x00\xd2\x00\xcd\x00\xd4\x00\x39\x00\xb9\x00\x08\x00\x09\x00\x39\x00\xbd\x00\xdb\x00\xdc\x00\x43\x00\x22\x00\x45\x00\xd8\x00\x47\x00\x39\x00\x49\x00\x4a\x00\x4b\x00\xc9\x00\xca\x00\x4e\x00\x4f\x00\xcd\x00\x51\x00\x47\x00\x39\x00\x49\x00\x4a\x00\x4b\x00\x43\x00\x39\x00\x45\x00\x52\x00\x47\x00\x97\x00\x49\x00\x4a\x00\x4b\x00\x37\x00\x38\x00\x4e\x00\x4f\x00\xd6\x00\x51\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x6a\x00\x43\x00\x17\x00\x45\x00\x17\x00\x47\x00\x16\x00\x49\x00\x4a\x00\x4b\x00\x22\x00\x4d\x00\x4e\x00\x4f\x00\x17\x00\xbc\x00\x16\x00\xc9\x00\x05\x00\x06\x00\xcc\x00\xcd\x00\x05\x00\x06\x00\x32\x00\x25\x00\x4a\x00\x27\x00\xc9\x00\x5c\x00\xcb\x00\xcc\x00\xcd\x00\x28\x00\x29\x00\xdb\x00\xdc\x00\x31\x00\x32\x00\x33\x00\x05\x00\x06\x00\x4a\x00\x4b\x00\x03\x00\x04\x00\xdb\x00\xdc\x00\x0c\x00\x43\x00\x8b\x00\x45\x00\x62\x00\x47\x00\x8b\x00\x49\x00\x4a\x00\x4b\x00\x90\x00\x4d\x00\x4e\x00\x4f\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x4a\x00\x4b\x00\x1c\x00\x43\x00\x4a\x00\x45\x00\x28\x00\x47\x00\x29\x00\x49\x00\x4a\x00\x4b\x00\x29\x00\x4d\x00\x4e\x00\x4f\x00\xbc\x00\x85\x00\x86\x00\x28\x00\x29\x00\x7a\x00\x22\x00\x17\x00\x24\x00\x25\x00\x17\x00\x27\x00\x28\x00\xc9\x00\x62\x00\xcb\x00\xcc\x00\xcd\x00\x05\x00\x06\x00\xbc\x00\x31\x00\x32\x00\x33\x00\xc9\x00\x0f\x00\x17\x00\xcc\x00\xcd\x00\x1c\x00\x29\x00\xdb\x00\xdc\x00\xc9\x00\x1d\x00\xcb\x00\xcc\x00\xcd\x00\x32\x00\x28\x00\xbc\x00\x27\x00\xdb\x00\xdc\x00\x32\x00\x1c\x00\x7a\x00\x2b\x00\x47\x00\x79\x00\x22\x00\xdb\x00\xdc\x00\xc9\x00\x0c\x00\xcb\x00\xcc\x00\xcd\x00\x43\x00\x17\x00\x45\x00\x64\x00\x47\x00\x17\x00\x49\x00\x4a\x00\x4b\x00\x22\x00\x4d\x00\x4e\x00\x4f\x00\xdb\x00\xdc\x00\x1e\x00\x05\x00\x8b\x00\x8b\x00\x17\x00\x32\x00\x43\x00\x1e\x00\x45\x00\x29\x00\x47\x00\x28\x00\x49\x00\x4a\x00\x4b\x00\xbc\x00\x4d\x00\x4e\x00\x4f\x00\x22\x00\x16\x00\x1c\x00\xc0\x00\x17\x00\x7b\x00\xc3\x00\x8b\x00\xc5\x00\xc9\x00\xc7\x00\xcb\x00\xcc\x00\xcd\x00\x4a\x00\x4b\x00\xbc\x00\xce\x00\xcf\x00\xd0\x00\x7a\x00\xd2\x00\x80\x00\xd4\x00\x29\x00\x8b\x00\x8b\x00\xdb\x00\xdc\x00\xc9\x00\x25\x00\xcb\x00\xcc\x00\xcd\x00\x43\x00\x22\x00\x45\x00\x1c\x00\x47\x00\x8b\x00\x49\x00\x4a\x00\x4b\x00\x8b\x00\x4d\x00\x4e\x00\x4f\x00\xdb\x00\xdc\x00\x47\x00\x1e\x00\x49\x00\x4a\x00\x4b\x00\x43\x00\x28\x00\x45\x00\x17\x00\x47\x00\x66\x00\x49\x00\x4a\x00\x4b\x00\x6b\x00\x4d\x00\x4e\x00\x4f\x00\x8b\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x1d\x00\x1d\x00\x43\x00\x17\x00\x45\x00\x31\x00\x47\x00\x1c\x00\x49\x00\x4a\x00\x4b\x00\x17\x00\x4d\x00\x4e\x00\x4f\x00\xbc\x00\x62\x00\x5d\x00\x05\x00\x1e\x00\x2b\x00\x2b\x00\x22\x00\x41\x00\x1c\x00\x25\x00\x22\x00\x27\x00\xc9\x00\x4c\x00\xcb\x00\xcc\x00\xcd\x00\x2d\x00\x29\x00\x0c\x00\xbc\x00\x31\x00\x32\x00\x33\x00\x22\x00\x17\x00\x28\x00\x62\x00\x24\x00\x24\x00\xdb\x00\xdc\x00\x7a\x00\xc9\x00\x1d\x00\xcb\x00\xcc\x00\xcd\x00\x43\x00\x62\x00\x45\x00\x2d\x00\x47\x00\x2b\x00\x49\x00\x4a\x00\x4b\x00\x1d\x00\x4d\x00\x4e\x00\x4f\x00\xdb\x00\xdc\x00\xc9\x00\x2c\x00\x1d\x00\xcc\x00\xcd\x00\x43\x00\x28\x00\x45\x00\x1d\x00\x47\x00\x22\x00\x49\x00\x4a\x00\x4b\x00\xbc\x00\x4d\x00\x4e\x00\x4f\x00\xdb\x00\xdc\x00\x21\x00\x29\x00\x0f\x00\x16\x00\x0f\x00\x46\x00\x1e\x00\xc9\x00\x0f\x00\xcb\x00\xcc\x00\xcd\x00\x4c\x00\x17\x00\xbc\x00\x17\x00\x66\x00\x28\x00\xc9\x00\x0c\x00\x28\x00\xcc\x00\xcd\x00\x8b\x00\x21\x00\xdb\x00\xdc\x00\xc9\x00\x1e\x00\xcb\x00\xcc\x00\xcd\x00\x8b\x00\x8b\x00\xbc\x00\x28\x00\xdb\x00\xdc\x00\x29\x00\x1e\x00\x1d\x00\x17\x00\x22\x00\x28\x00\x7a\x00\xdb\x00\xdc\x00\xc9\x00\x7a\x00\xcb\x00\xcc\x00\xcd\x00\x43\x00\x2b\x00\x45\x00\x7a\x00\x47\x00\x24\x00\x49\x00\x4a\x00\x4b\x00\x7a\x00\x4d\x00\x4e\x00\x4f\x00\xdb\x00\xdc\x00\x66\x00\x62\x00\x22\x00\x24\x00\x27\x00\x43\x00\x1c\x00\x45\x00\x1d\x00\x47\x00\x1e\x00\x49\x00\x4a\x00\x4b\x00\x77\x00\x4d\x00\x4e\x00\x4f\x00\x47\x00\xbc\x00\x17\x00\x24\x00\x24\x00\x1b\x00\x29\x00\x22\x00\xc0\x00\x8b\x00\x05\x00\xc3\x00\x1c\x00\xc5\x00\xc9\x00\xc7\x00\xcb\x00\xcc\x00\xcd\x00\x17\x00\x17\x00\xbc\x00\xce\x00\xcf\x00\xd0\x00\x17\x00\xd2\x00\x7c\x00\xd4\x00\x17\x00\x17\x00\x17\x00\xdb\x00\xdc\x00\xc9\x00\x22\x00\xcb\x00\xcc\x00\xcd\x00\x43\x00\x17\x00\x45\x00\x17\x00\x47\x00\x21\x00\x49\x00\x4a\x00\x4b\x00\x2d\x00\x4d\x00\x4e\x00\x4f\x00\xdb\x00\xdc\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x2b\x00\x43\x00\x17\x00\x45\x00\x21\x00\x47\x00\x41\x00\x49\x00\x4a\x00\x4b\x00\x74\x00\x4d\x00\x4e\x00\x4f\x00\x27\x00\x1c\x00\x41\x00\x41\x00\x4c\x00\x6b\x00\x8b\x00\x43\x00\x2d\x00\x45\x00\x64\x00\x47\x00\x8b\x00\x49\x00\x4a\x00\x4b\x00\xbc\x00\x0c\x00\x4e\x00\x4f\x00\x17\x00\x17\x00\x17\x00\xc0\x00\x22\x00\x17\x00\xc3\x00\x21\x00\xc5\x00\xc9\x00\xc7\x00\xcb\x00\xcc\x00\xcd\x00\x2b\x00\x7a\x00\xbc\x00\xce\x00\xcf\x00\xd0\x00\x20\x00\xd2\x00\x29\x00\xd4\x00\x22\x00\x0f\x00\x05\x00\xdb\x00\xdc\x00\xc9\x00\x8b\x00\xcb\x00\xcc\x00\xcd\x00\x43\x00\x6b\x00\x45\x00\x1d\x00\x47\x00\x8c\x00\x49\x00\x4a\x00\x4b\x00\x72\x00\x0f\x00\x4e\x00\x4f\x00\xdb\x00\xdc\x00\x20\x00\x6f\x00\x1d\x00\x16\x00\x65\x00\x43\x00\x0c\x00\x45\x00\x0f\x00\x47\x00\x28\x00\x49\x00\x4a\x00\x4b\x00\x0f\x00\x8c\x00\x4e\x00\x4f\x00\x0f\x00\xbc\x00\x1d\x00\x8c\x00\x8c\x00\x2c\x00\x1d\x00\x1d\x00\x1d\x00\x2c\x00\x00\x00\x8c\x00\x72\x00\xff\xff\xc9\x00\xff\xff\xcb\x00\xcc\x00\xcd\x00\xff\xff\xff\xff\xbc\x00\xff\xff\xff\xff\xc9\x00\xff\xff\xff\xff\xcc\x00\xcd\x00\xff\xff\xff\xff\xff\xff\xdb\x00\xdc\x00\xc9\x00\xff\xff\xcb\x00\xcc\x00\xcd\x00\xff\xff\xff\xff\xbc\x00\xdb\x00\xdc\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xdb\x00\xdc\x00\xc9\x00\xff\xff\xcb\x00\xcc\x00\xcd\x00\x43\x00\xff\xff\x45\x00\xff\xff\x47\x00\xff\xff\x49\x00\x4a\x00\x4b\x00\xff\xff\xff\xff\x4e\x00\x4f\x00\xdb\x00\xdc\x00\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\x43\x00\xff\xff\x45\x00\xff\xff\x47\x00\xff\xff\x49\x00\x4a\x00\x4b\x00\xbc\x00\xff\xff\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\xc9\x00\xff\xff\xcb\x00\xcc\x00\xcd\x00\xff\xff\xff\xff\xbc\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xdb\x00\xdc\x00\xc9\x00\xff\xff\xcb\x00\xcc\x00\xcd\x00\x43\x00\xff\xff\x45\x00\xff\xff\x47\x00\xff\xff\x49\x00\x4a\x00\x4b\x00\xff\xff\xff\xff\x4e\x00\x4f\x00\xdb\x00\xdc\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\xff\xff\x43\x00\xff\xff\x45\x00\xff\xff\x47\x00\x96\x00\x49\x00\x4a\x00\x4b\x00\x50\x00\xff\xff\x4e\x00\x4f\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x43\x00\x5c\x00\x45\x00\xff\xff\x47\x00\xff\xff\x49\x00\x4a\x00\x4b\x00\xff\xff\xff\xff\x4e\x00\x4f\x00\x68\x00\xbc\x00\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xc9\x00\xff\xff\xcb\x00\xcc\x00\xcd\x00\x7b\x00\xff\xff\xbc\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xdb\x00\xdc\x00\xc9\x00\xd5\x00\xcb\x00\xcc\x00\xcd\x00\x43\x00\xff\xff\x45\x00\xff\xff\x47\x00\xff\xff\x49\x00\x4a\x00\x4b\x00\xff\xff\xff\xff\x4e\x00\x4f\x00\xdb\x00\xdc\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x43\x00\xff\xff\x45\x00\xff\xff\x47\x00\xff\xff\x49\x00\x4a\x00\x4b\x00\xbc\x00\xff\xff\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xff\xff\xcb\x00\xcc\x00\xcd\x00\xff\xff\xff\xff\xbc\x00\x43\x00\x44\x00\x45\x00\xff\xff\x47\x00\xff\xff\x49\x00\x4a\x00\x4b\x00\xff\xff\xdb\x00\xdc\x00\xc9\x00\xff\xff\xcb\x00\xcc\x00\xcd\x00\x43\x00\xff\xff\xbc\x00\xff\xff\x47\x00\xff\xff\x49\x00\x4a\x00\x4b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xdb\x00\xdc\x00\xc9\x00\xff\xff\xcb\x00\xcc\x00\xcd\x00\x43\x00\xff\xff\x45\x00\xff\xff\x47\x00\xff\xff\x49\x00\x4a\x00\x4b\x00\xff\xff\xff\xff\x4e\x00\x4f\x00\xdb\x00\xdc\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x43\x00\xff\xff\x45\x00\xff\xff\x47\x00\xff\xff\x49\x00\x4a\x00\x4b\x00\xff\xff\xff\xff\x4e\x00\x4f\x00\xff\xff\xbc\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\xc9\x00\xff\xff\xcb\x00\xcc\x00\xcd\x00\xff\xff\x43\x00\xbc\x00\x45\x00\xff\xff\x47\x00\xff\xff\x49\x00\x4a\x00\x4b\x00\xff\xff\xff\xff\xff\xff\xdb\x00\xdc\x00\xc9\x00\xff\xff\xcb\x00\xcc\x00\xcd\x00\xff\xff\x43\x00\xff\xff\x45\x00\xff\xff\x47\x00\xff\xff\x49\x00\x4a\x00\x4b\x00\xff\xff\xff\xff\xbc\x00\xdb\x00\xdc\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xff\xff\xcb\x00\xcc\x00\xcd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\xff\xff\xc9\x00\xdb\x00\xdc\x00\xcc\x00\xcd\x00\x46\x00\x47\x00\xbc\x00\x49\x00\x4a\x00\x4b\x00\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\xff\xff\xdb\x00\xdc\x00\xc9\x00\xff\xff\xcb\x00\xcc\x00\xcd\x00\x46\x00\x47\x00\xbc\x00\x49\x00\x4a\x00\x4b\x00\xff\xff\x61\x00\x62\x00\x63\x00\xff\xff\x65\x00\xff\xff\xdb\x00\xdc\x00\xc9\x00\xff\xff\xcb\x00\xcc\x00\xcd\x00\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\xff\xff\x61\x00\x62\x00\x63\x00\xff\xff\x65\x00\xff\xff\xdb\x00\xdc\x00\xbc\x00\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\xc9\x00\xff\xff\xcb\x00\xcc\x00\xcd\x00\xff\xff\xff\xff\xbc\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\xff\xff\xdb\x00\xdc\x00\xc9\x00\xff\xff\xcb\x00\xcc\x00\xcd\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xdb\x00\xdc\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xff\xff\xff\xff\xff\xff\xc7\x00\xff\xff\xc9\x00\xff\xff\xbe\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xff\xff\xff\xff\xcc\x00\xcd\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xdb\x00\xdc\x00\xc9\x00\xff\xff\xff\xff\xcc\x00\xcd\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\xdb\x00\xdc\x00\xc9\x00\xff\xff\xff\xff\xcc\x00\xcd\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\xc9\x00\xdb\x00\xdc\x00\xcc\x00\xcd\x00\xc9\x00\xff\xff\xff\xff\xcc\x00\xcd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xdb\x00\xdc\x00\xcc\x00\xcd\x00\xc9\x00\xdb\x00\xdc\x00\xcc\x00\xcd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x00\xdb\x00\xdc\x00\xcc\x00\xcd\x00\xc9\x00\xdb\x00\xdc\x00\xcc\x00\xcd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xdb\x00\xdc\x00\xff\xff\xff\xff\xff\xff\xdb\x00\xdc\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\x1c\x00\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\x7c\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\x69\x00\x6a\x00\xff\xff\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\xff\xff\x73\x00\xff\xff\x75\x00\xff\xff\xff\xff\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\x8a\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xc0\x00\x18\x00\xff\xff\xc3\x00\xff\xff\xc5\x00\xff\xff\xc7\x00\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xce\x00\xcf\x00\xd0\x00\xff\xff\xd2\x00\x2a\x00\xd4\x00\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\x69\x00\x6a\x00\xff\xff\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\xff\xff\x73\x00\xff\xff\x75\x00\xff\xff\xff\xff\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\xff\xff\xff\xff\xff\xff\x8a\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\x69\x00\xff\xff\xff\xff\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x01\x00\x73\x00\xff\xff\x75\x00\x05\x00\x06\x00\x78\x00\xff\xff\x09\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x16\x00\xff\xff\x18\x00\x8a\x00\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\x20\x00\xff\xff\xff\xff\xff\xff\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\xff\xff\x32\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\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x16\x00\x5c\x00\x18\x00\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\x20\x00\xff\xff\x09\x00\x68\x00\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x16\x00\x5c\x00\x18\x00\x32\x00\xff\xff\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x68\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\x87\x00\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\xff\xff\x7b\x00\x50\x00\x51\x00\x52\x00\x53\x00\x0f\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x16\x00\x5c\x00\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\x66\x00\xff\xff\x68\x00\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x16\x00\x5c\x00\x18\x00\xff\xff\x01\x00\xff\xff\xff\xff\x7b\x00\x05\x00\x06\x00\x20\x00\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x87\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\x32\x00\xff\xff\xff\xff\xff\xff\x7b\x00\x50\x00\xff\xff\x20\x00\xff\xff\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x87\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\xff\xff\x68\x00\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\x7b\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\x68\x00\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x16\x00\x5c\x00\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x68\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\xff\xff\x87\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\x24\x00\x25\x00\x87\x00\x27\x00\x28\x00\x29\x00\xff\xff\x2b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x68\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\xff\xff\x18\x00\x19\x00\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\x00\x23\x00\x24\x00\x25\x00\x87\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\xff\xff\xff\xff\xff\xff\x75\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\xff\xff\xff\xff\xff\xff\x75\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\xff\xff\xff\xff\xff\xff\x75\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\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\xff\xff\x18\x00\x19\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\xff\xff\xff\xff\xff\xff\x75\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\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\xff\xff\x18\x00\x19\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\xff\xff\xff\xff\xff\xff\x75\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\xff\xff\xff\xff\xff\xff\x75\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\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\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\xff\xff\xff\xff\xff\xff\x75\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\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\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\xff\xff\xff\xff\xff\xff\x75\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\x1c\x00\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\xff\xff\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\x1c\x00\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\xff\xff\xff\xff\xff\xff\x75\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\xff\xff\xff\xff\xff\xff\x75\x00\xff\xff\x77\x00\xff\xff\xff\xff\xff\xff\x7b\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\xff\xff\xff\xff\xff\xff\x75\x00\x76\x00\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\xff\xff\xff\xff\xff\xff\x75\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\xff\xff\xff\xff\xff\xff\x75\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\xff\xff\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\xff\xff\xff\xff\xff\xff\x75\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\xff\xff\xff\xff\xff\xff\x75\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\xff\xff\xff\xff\xff\xff\x75\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\xff\xff\xff\xff\xff\xff\x75\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\x1c\x00\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\x60\x00\xff\xff\xff\xff\x63\x00\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\x6c\x00\x6d\x00\x6e\x00\xff\xff\xff\xff\x71\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\x60\x00\xff\xff\xff\xff\x63\x00\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\x6c\x00\x6d\x00\x6e\x00\xff\xff\xff\xff\x71\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\x1c\x00\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\x60\x00\xff\xff\xff\xff\x63\x00\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\x71\x00\xff\xff\x73\x00\x96\x00\xff\xff\xff\xff\xff\xff\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xb8\x00\x18\x00\xff\xff\xbb\x00\xbc\x00\x1c\x00\xbe\x00\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xd5\x00\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x88\x00\x5c\x00\x8a\x00\x5e\x00\xff\xff\x8d\x00\x8e\x00\x8f\x00\x63\x00\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\x96\x00\xff\xff\xff\xff\x6c\x00\x6d\x00\x6e\x00\xff\xff\xff\xff\x71\x00\xff\xff\xff\xff\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xb8\x00\x18\x00\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xd5\x00\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\x60\x00\xff\xff\xff\xff\x63\x00\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\xff\xff\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\x71\x00\xff\xff\x73\x00\xff\xff\xff\xff\x96\x00\xff\xff\x78\x00\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xd5\x00\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\x6c\x00\x6d\x00\x6e\x00\xff\xff\xff\xff\x71\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\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\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\x7b\x00\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\x2f\x00\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x96\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\x7b\x00\xbe\x00\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\x2f\x00\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\xff\xff\xd5\x00\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x96\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\x7b\x00\xbe\x00\x20\x00\x01\x00\xff\xff\x23\x00\xff\xff\x05\x00\xff\xff\x07\x00\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd5\x00\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x7b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\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\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\x08\x00\x09\x00\x0a\x00\x0b\x00\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\x16\x00\x17\x00\x18\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\x00\xff\xff\xff\xff\x25\x00\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\xff\xff\x24\x00\x25\x00\xb8\x00\x27\x00\x28\x00\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xd5\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x01\x00\x5c\x00\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\x08\x00\x09\x00\xff\xff\x0b\x00\x66\x00\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x16\x00\xff\xff\x18\x00\x05\x00\x06\x00\xff\xff\x08\x00\x09\x00\xff\xff\x0b\x00\x20\x00\x7b\x00\xff\xff\xff\xff\x24\x00\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\x2d\x00\xff\xff\x2f\x00\x30\x00\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\x24\x00\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\x2f\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\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\x50\x00\x51\x00\x52\x00\x53\x00\x68\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\x19\x00\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\x68\x00\x20\x00\x01\x00\x22\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\x16\x00\x17\x00\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\x20\x00\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x01\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x7b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\x16\x00\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x7b\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x16\x00\x5c\x00\x18\x00\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\x05\x00\x06\x00\x20\x00\x66\x00\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\x50\x00\x51\x00\x52\x00\x53\x00\x22\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\x65\x00\x66\x00\xff\xff\x68\x00\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x16\x00\x5c\x00\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\x20\x00\x66\x00\xff\xff\x68\x00\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x02\x00\xff\xff\x72\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\x20\x00\x21\x00\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x01\x00\x02\x00\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\x50\x00\x51\x00\x52\x00\x53\x00\x7b\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x68\x00\x5c\x00\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x7b\x00\x5c\x00\xff\xff\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\x72\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\xff\xff\x20\x00\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x7b\x00\x5c\x00\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x68\x00\x5c\x00\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\x6f\x00\xff\xff\xff\xff\x16\x00\x17\x00\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x17\x00\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\x26\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x16\x00\xff\xff\x18\x00\x05\x00\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x20\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x65\x00\x66\x00\xff\xff\x68\x00\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\x7b\x00\xff\xff\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\x7b\x00\xff\xff\x01\x00\x02\x00\x50\x00\x51\x00\x52\x00\x53\x00\x68\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\x65\x00\x66\x00\x7b\x00\x68\x00\x01\x00\xff\xff\x1e\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x26\x00\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\x16\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x02\x00\xff\xff\x68\x00\x05\x00\x06\x00\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\x16\x00\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\x65\x00\x66\x00\x05\x00\x68\x00\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\x16\x00\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\xff\xff\xff\xff\xff\xff\x01\x00\x02\x00\x78\x00\xff\xff\xff\xff\x7b\x00\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\x1e\x00\x68\x00\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\x01\x00\xff\xff\xff\xff\x7b\x00\x05\x00\x06\x00\xff\xff\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\x20\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x01\x00\x5c\x00\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x7b\x00\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x16\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\x68\x00\xff\xff\xff\xff\x26\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\x7b\x00\x50\x00\x51\x00\x52\x00\x53\x00\x20\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\x68\x00\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\x65\x00\x66\x00\x20\x00\x68\x00\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\x7b\x00\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\x68\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\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\x7b\x00\x50\x00\x51\x00\x52\x00\x53\x00\x20\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x16\x00\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\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\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x68\x00\x5c\x00\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x7b\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\x16\x00\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\xff\xff\x68\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\x16\x00\x50\x00\x51\x00\x52\x00\x53\x00\x7b\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\x01\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x7b\x00\x5c\x00\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\x65\x00\x66\x00\x05\x00\x68\x00\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\x01\x00\xff\xff\x65\x00\x66\x00\xff\xff\x68\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\x7b\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x01\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\x16\x00\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x25\x00\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x16\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x7b\x00\x5c\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\xff\xff\xff\xff\x25\x00\xff\xff\xff\xff\x01\x00\xff\xff\x68\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\x24\x00\x25\x00\x7b\x00\x27\x00\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x68\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x7b\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x68\x00\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xff\xff\xa6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xae\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd5\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa2\x00\xa3\x00\xa4\x00\xff\xff\xa6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xae\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd5\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\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\xa3\x00\xa4\x00\xff\xff\xa6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xae\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd5\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\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\xa5\x00\xa6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xae\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd5\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\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\xae\x00\xff\xff\xb0\x00\xff\xff\xb2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd5\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\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\xa5\x00\xa6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xae\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd5\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\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\xae\x00\xff\xff\xb0\x00\xff\xff\xb2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd5\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\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\xa5\x00\xa6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xae\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd5\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\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\xae\x00\xff\xff\xb0\x00\xff\xff\xb2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd5\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\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\xae\x00\xff\xff\xb0\x00\xff\xff\xb2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd5\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\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\xa6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xae\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd5\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xae\x00\xff\xff\xff\xff\x96\x00\xb2\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xd5\x00\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd5\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xd5\x00\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd5\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xd5\x00\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd5\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xd5\x00\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd5\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xd5\x00\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd5\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xd5\x00\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd5\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xd5\x00\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd5\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xd5\x00\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd5\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\x95\x00\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xd5\x00\xff\xff\xc1\x00\xff\xff\xc3\x00\xff\xff\xff\xff\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9f\x00\xa0\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xc1\x00\xff\xff\xc3\x00\xff\xff\xff\xff\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xff\xff\xd1\x00\xff\xff\xd3\x00\xd4\x00\xd5\x00\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xc1\x00\xff\xff\xc3\x00\xff\xff\xff\xff\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xff\xff\xd1\x00\xff\xff\xd3\x00\xd4\x00\xd5\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xc1\x00\xff\xff\xc3\x00\xff\xff\xff\xff\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xff\xff\xd1\x00\xff\xff\xd3\x00\xd4\x00\xd5\x00\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xc1\x00\xff\xff\xc3\x00\xff\xff\xff\xff\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xff\xff\xd1\x00\xff\xff\xd3\x00\xd4\x00\xd5\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xc1\x00\xff\xff\xc3\x00\xff\xff\xff\xff\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xff\xff\xd1\x00\xff\xff\xd3\x00\xd4\x00\xd5\x00\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xc1\x00\xff\xff\xc3\x00\xff\xff\xff\xff\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xff\xff\xd1\x00\xff\xff\xd3\x00\xd4\x00\xd5\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\x91\x00\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xc1\x00\xff\xff\xc3\x00\xff\xff\xff\xff\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xff\xff\xd1\x00\xff\xff\xd3\x00\xd4\x00\xd5\x00\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xc1\x00\xff\xff\xc3\x00\xff\xff\xff\xff\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xff\xff\xd1\x00\xff\xff\xd3\x00\xd4\x00\xd5\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\x96\x00\xff\xff\xae\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xaa\x00\xff\xff\xff\xff\xff\xff\xae\x00\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xd5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd5\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\xff\xff\x96\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\x00\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xd5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd5\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x94\x00\xff\xff\x96\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xae\x00\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xd5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd5\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xd5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd5\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xd5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd5\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xd5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd5\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xd5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd5\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xd5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd5\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xd5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd5\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xd5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd5\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xd5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd5\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xd5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xff\xff\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd5\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xd5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd5\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\x85\x00\xbe\x00\xd5\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\x96\x00\xff\xff\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xd5\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xd5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xd5\x00\xff\xff\x96\x00\xff\xff\xff\xff\x99\x00\x9a\x00\x9b\x00\xff\xff\x9d\x00\x9e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xff\xff\x99\x00\x9a\x00\x9b\x00\xff\xff\x9d\x00\x9e\x00\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xd5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xd5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xd5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xd5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xd5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8d\x00\x8e\x00\x8f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xb8\x00\xff\xff\xff\xff\xbb\x00\xbc\x00\xff\xff\xbe\x00\xd5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd5\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"#++happyTable :: HappyAddr+happyTable = HappyA# "\x00\x00\x0c\x00\x09\x00\x0b\x00\x9d\x00\x09\x00\x9e\x00\x45\x02\x65\x03\x66\x03\x67\x03\x72\x03\x4e\x03\xf6\x02\x53\x04\x42\x04\xf8\x01\x35\x03\x8f\x01\x0b\x03\xc0\x00\x18\x03\x8d\x01\x4d\x03\x4e\x03\x31\x03\x54\x04\x55\x04\xf1\x00\x8f\x01\x21\x02\x6e\x02\xc0\x00\xba\xff\xc0\x00\x6e\x02\xff\x03\x34\x03\xb3\x02\xc1\x00\x8f\x01\x21\x02\xc2\x01\x8f\x01\x89\x03\x8f\x01\x0b\x03\x77\x02\x8f\x01\xa5\x03\x8f\x01\x3e\x03\x8f\x01\x3e\x03\xb8\x00\xc0\x00\xd3\x01\xd8\x00\x22\x02\xda\x00\x0c\x01\x6f\x00\x5a\x04\x05\x01\x34\x02\x0b\x01\x36\x02\xba\x03\x97\x03\x24\x02\xd7\x00\xd8\x00\x36\x02\x8f\x01\xa5\x03\x0e\x01\xd0\x01\x94\x01\xd1\x01\xe8\x03\x72\x00\xfc\x01\xa3\x00\xf2\x00\xa4\x00\xb4\x02\x0b\x03\xde\x00\xd7\x00\xd8\x00\xd1\x00\xd2\x00\xf3\x00\x30\x02\xd4\x00\xbb\x03\xd5\x00\xd4\x01\x4a\x00\xdd\x00\x4b\x00\x4c\x00\x06\x01\x5d\x04\x06\x01\xd5\x01\x8f\x01\x89\x03\x95\x01\x5f\x04\x02\x04\xe0\x00\xe1\x00\xe2\x00\x06\x01\x51\x04\xff\x01\xdd\x00\x19\x03\x25\x00\xc0\x03\x5a\x03\x5b\x03\x01\x04\x02\x04\xa6\x03\xa5\x00\x4c\x04\x31\x02\xe0\x00\xe1\x00\xe2\x00\xf4\x01\xba\x00\x7a\x00\xd0\x01\x7b\x00\xd1\x01\x5c\x03\xc9\x01\xca\x01\x7d\x00\xf6\x02\x8a\x03\xf7\x03\x7e\x00\xf2\x02\x7f\x00\x80\x00\x78\x02\xa7\x03\x11\x04\x12\x04\x21\x00\x4f\x03\x3f\x03\x7a\x00\x40\x03\x7b\x00\x29\x04\xf8\x03\xc9\x01\xca\x01\x7d\x00\x79\x02\x21\x00\x4f\x03\x7e\x00\x03\x04\x7f\x00\x80\x00\xf9\x01\x04\x04\x0c\x03\xfa\x01\x35\x02\xfb\x01\x37\x02\x68\x03\x78\x02\x06\x02\x69\x03\x56\x04\x3a\x02\x21\x00\xa9\x00\x57\x04\xfc\x01\xaa\x00\xc2\x00\xfd\x01\x20\x00\x21\x00\x22\x00\x79\x02\x24\x00\x25\x00\x23\x02\x21\x00\xa9\x00\x0d\x03\xc2\x00\xaa\x00\xc2\x00\x68\x03\x3f\x04\x8b\x03\x69\x03\x25\x02\x6a\x03\x46\x02\x8e\x01\x0a\x00\x0a\x00\x58\x04\x0a\x00\x0a\x00\x20\x00\x21\x00\x22\x00\x8e\x01\x24\x00\x25\x00\x81\x00\xc2\x00\xd8\x00\xd4\x03\xfd\x02\x68\x00\x69\x00\x6a\x00\x82\x00\x10\x00\x83\x00\x12\x00\x6a\x03\xee\x00\x13\x00\x14\x00\x15\x00\xd9\x03\xcb\x01\x16\x00\x17\x00\x18\x00\x81\x00\xa5\x00\x8c\x01\xd1\x00\xd2\x00\x6f\x00\x19\x00\x99\x03\x82\x00\x10\x00\x83\x00\x12\x00\xd0\x03\x56\x04\x13\x00\x14\x00\x15\x00\x57\x04\x03\x04\x16\x00\x17\x00\x18\x00\x04\x04\xf5\x01\x72\x00\x96\x02\x24\x00\x25\x00\x19\x00\x21\x00\xa9\x00\x79\x01\x03\x04\xaa\x00\x21\x00\xa9\x00\x04\x04\x43\x04\xaa\x00\xb2\x01\x1c\x00\xa5\x00\xfb\x02\x1d\x00\x1e\x00\x58\x04\x1f\x00\x31\x04\x21\x00\xa9\x00\xca\x00\x7a\x01\xaa\x00\x97\x02\x98\x02\xcf\x01\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x7b\x01\x03\x03\x1d\x00\x1e\x00\xf5\xff\x1f\x00\x26\x00\xd0\x01\x07\x02\xd1\x01\xc2\x01\x37\x03\xaa\x01\xcb\x00\xf9\x02\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x20\x00\x21\x00\x22\x00\x04\x03\x7a\x00\x79\x02\x7b\x00\x26\x00\xc8\x01\xc9\x01\xca\x01\x7d\x00\xc3\x01\x9c\x01\x9d\x01\x7e\x00\xe5\x01\x7f\x00\x80\x00\x8c\x02\xbd\x00\x9e\x01\x68\x00\x69\x00\x6a\x00\x17\x04\x7a\x00\x6f\x00\x7b\x00\x33\x04\x70\x00\x25\x00\x05\x03\x7d\x00\x20\x00\x21\x00\x22\x00\x7e\x00\xa7\x00\x7f\x00\x80\x00\x1a\x02\xa8\x00\xce\x03\xcf\x03\x71\x00\x72\x00\x07\x02\x2f\x03\x2c\x00\x2d\x00\x9f\x00\xfe\x02\x34\x04\x21\x00\xa9\x00\xa0\x00\xa1\x00\xaa\x00\xb2\x01\x20\x00\x21\x00\x22\x00\xf7\x02\x21\x00\xa9\x00\xd2\x03\x65\x00\x1b\x02\x1c\x02\x9e\x01\x67\x00\x6e\x02\x68\x00\x69\x00\x6a\x00\xd7\x00\x78\x03\xe9\x00\x6d\x00\x1d\x02\xf0\x00\x79\x03\x20\x00\x21\x00\x22\x00\xbd\x01\xaa\x01\x08\x04\xe8\x02\xbe\x01\x0d\x04\x0e\x04\x81\x00\x0f\x04\xbf\x01\xbd\x00\x23\x00\x68\x00\x69\x00\x6a\x00\x82\x00\x10\x00\x83\x00\x12\x00\xdd\x00\x09\x04\x13\x00\x14\x00\x15\x00\xef\x01\x64\x04\x16\x00\x17\x00\x18\x00\x81\x00\x72\x02\xe0\x00\xe1\x00\xe2\x00\x88\x03\x19\x00\x3d\x04\x82\x00\x10\x00\x83\x00\x12\x00\xf0\x01\x6f\x00\x13\x00\x14\x00\x15\x00\x53\x02\xb1\x00\x16\x00\x17\x00\x18\x00\x70\x01\x7a\x00\xd4\x00\x7b\x00\xd5\x00\xd0\x03\x19\x00\x7c\x00\x7d\x00\x3c\x03\x72\x00\x6f\x00\x7e\x00\x6f\x00\x7f\x00\x80\x00\x70\x00\x25\x00\x1c\x00\x24\x00\x25\x00\x1d\x00\x1e\x00\x6f\x00\x1f\x00\xb2\x01\xb8\x01\x25\x00\xe1\x02\xa2\x02\x72\x00\x71\x00\x72\x00\x37\x04\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\xe4\x01\x72\x00\x1d\x00\x1e\x00\x9c\x02\x1f\x00\x26\x00\x2c\x00\x2d\x00\x72\x02\x6e\x00\xb2\x01\x73\x02\x74\x02\xb3\x01\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x02\x9d\x02\x6f\x00\xd2\x03\x23\x00\x70\x00\x25\x00\x26\x00\xdf\x03\x27\x02\xf8\x00\x69\x00\x6a\x00\xbd\x00\x6e\x00\x68\x00\x69\x00\x6a\x00\x01\x02\x8c\x02\x71\x00\x72\x00\x03\x03\xe3\x02\xd7\x00\x8d\x02\xd9\x00\x6f\x00\x81\x00\x23\x00\x70\x00\x25\x00\xee\x00\x28\x04\x2c\x00\x2d\x00\x82\x00\x10\x00\x83\x00\x12\x00\x21\x00\x71\x03\x13\x00\x14\x00\x15\x00\x71\x00\x72\x00\x16\x00\x17\x00\x18\x00\x7a\x00\x1b\x03\x7b\x00\xdd\x00\x3c\x02\xa7\x00\x19\x00\x3d\x02\x3c\x04\xa8\x00\x38\x04\xe2\x03\xfb\x02\x7f\x00\x80\x00\xe0\x00\xe1\x00\xe2\x00\x2b\x02\x3d\x04\xb5\x01\x21\x00\xa9\x00\xee\x00\x7a\x00\xaa\x00\x7b\x00\x3e\x04\xaa\x01\xee\x00\xab\x01\x20\x00\x21\x00\x22\x00\x67\x02\x68\x02\xf9\x01\x7f\x00\x80\x00\xfa\x01\x1c\x00\x13\x03\xea\x02\x1d\x00\x1e\x00\xed\x00\x1f\x00\x4d\x04\x4e\x04\x4f\x04\xfc\x03\xad\x01\xfc\x01\xee\x00\xee\x00\xfd\x01\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xee\x00\xe9\x03\x27\x02\x2c\x02\x1a\x04\x1b\x04\xbd\x00\x26\x00\x68\x00\x69\x00\x6a\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\x21\x04\x20\x00\x21\x00\x22\x00\xe3\x03\xe4\x03\xe5\x03\xae\x00\xaf\x00\xb0\x00\xb1\x00\x6f\x00\x81\x00\xcc\x03\x70\x00\x25\x00\x6f\x00\xd9\x03\x22\x04\x70\x00\x25\x00\xc5\x03\x69\x02\xc6\x03\xdc\x00\xdd\x00\x13\x00\xde\x00\x15\x00\x71\x00\x72\x00\x16\x00\x17\x00\x18\x00\x71\x00\x72\x00\x81\x00\xe0\x00\xe1\x00\xe2\x00\x19\x00\x03\x03\xec\x01\xc6\x03\xc7\x03\xf1\x01\x69\x02\x7a\x00\x34\x03\x7b\x00\x13\x00\x9f\x02\x15\x00\xb0\x01\xb0\x01\x16\x00\x17\x00\x18\x00\xe2\x03\xe6\x01\x7f\x00\x80\x00\xe0\x03\xbd\x00\x19\x00\x68\x00\x69\x00\x6a\x00\xda\x03\xdb\x03\xf2\x01\x7a\x00\x15\x04\x7b\x00\x1c\x00\xf1\x03\x16\x04\x1d\x00\x1e\x00\xf3\x01\x1f\x00\x8b\x01\x77\x03\xef\x02\x7f\x00\x80\x00\xf3\x03\xf0\x02\x8a\x01\xa1\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x6a\x02\x6b\x02\x1c\x00\xcb\x01\xfa\x03\x1d\x00\x6c\x02\x26\x00\x1f\x00\xf6\x03\xd1\x00\xd2\x00\x70\x01\x2e\xfe\xd4\x00\x2e\xfe\xd5\x00\x5f\x03\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x40\xfe\x6f\x00\x40\xfe\x3d\x02\x70\x00\x25\x00\x89\x01\x26\x00\x2e\x02\x32\x04\xe5\x03\xa7\x00\x7b\x03\x8a\x01\xa1\x00\xa8\x00\x81\x00\xa3\x03\x94\x02\x71\x00\x72\x00\x20\x00\x21\x00\x22\x00\xeb\x03\xec\x03\x69\x02\x21\x00\xa9\x00\xab\x03\x13\x00\xaa\x00\x15\x00\x07\x02\x7d\x03\x16\x00\x17\x00\x18\x00\x21\x00\x9e\x02\x81\x00\x7e\x03\x9f\x02\x42\xfe\x19\x00\x42\xfe\x20\x00\x21\x00\x22\x00\x48\x01\x69\x02\x43\xfe\x49\x01\x43\xfe\x13\x00\xae\x03\x15\x00\x31\x02\x7d\x03\x16\x00\x17\x00\x18\x00\x20\x00\x21\x00\x22\x00\x7e\x03\x24\x00\x25\x00\x19\x00\xaf\x03\x20\x00\x21\x00\x22\x00\x6f\x00\x61\x03\x62\x03\x70\x00\x25\x00\x1c\x00\x86\x03\x87\x03\x1d\x00\x1e\x00\xb5\x03\x1f\x00\xd4\x01\x4a\x00\xff\x03\x4b\x00\x4c\x00\x16\x03\x71\x00\x72\x00\xd5\x01\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1b\x03\x4a\xfe\x1c\x00\x4a\xfe\x17\x03\x1d\x00\x1e\x00\x26\x00\x1f\x00\x7e\x02\x7f\x02\x80\x02\x81\x02\x7f\x03\x80\x03\x81\x03\x82\x03\x20\x03\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x91\x03\x90\x02\x83\x03\x26\x04\x13\x01\x14\x01\x13\x00\x26\x00\x15\x00\x1e\x03\x94\x02\x16\x00\x17\x00\x18\x00\x0a\x04\x81\x03\x82\x03\x3d\x04\x13\x01\x14\x01\x19\x00\xe7\x01\xee\x03\x49\x03\x1d\x03\xbd\x00\x83\x03\x68\x00\x69\x00\x6a\x00\x13\x00\x4b\xfe\x15\x00\x4b\xfe\x36\x03\x16\x00\x17\x00\x18\x00\xc1\x03\xc2\x03\xc3\x03\x65\x00\x39\x03\x66\x00\x19\x00\x67\x00\x57\x03\x68\x00\x69\x00\x6a\x00\x54\x03\x55\x03\x4a\x03\x6d\x00\x1c\x00\x42\x03\x43\x03\x1d\x00\x1e\x00\x59\x03\x1f\x00\xb2\x00\xaf\x00\xb0\x00\xb1\x00\xac\x03\x93\x02\x94\x02\x45\x03\x46\x03\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x4b\x02\x4c\xfe\x1c\x00\x4c\xfe\x4d\x02\x1d\x00\x1e\x00\x26\x00\x1f\x00\x48\x03\x49\x03\x54\x02\xb0\x00\xb1\x00\x55\x02\x48\x02\x8f\x01\x49\x02\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x52\x04\x94\x03\x69\x00\x6a\x00\x65\x00\x56\x02\x66\x00\x26\x00\x67\x00\x61\x02\x68\x00\x69\x00\x6a\x00\x4c\x03\x49\x03\x4a\x03\x6d\x00\x4a\x02\x8f\x01\x49\x02\x8c\x03\x27\x02\x92\x02\x93\x02\x94\x02\xbd\x00\x6e\x02\x68\x00\x69\x00\x6a\x00\x63\x02\x4d\xfe\x65\x00\x4d\xfe\x66\x00\xc7\xfe\x67\x00\xc7\xfe\x68\x00\x69\x00\x6a\x00\x26\x02\x27\x02\x4a\x03\x6d\x00\x4e\xfe\xbd\x00\x4e\xfe\x68\x00\x69\x00\x6a\x00\x64\x02\xb7\x01\x21\x00\x22\x00\x6f\x00\xb8\x01\x25\x00\x70\x00\x25\x00\xce\x02\x14\x01\x6e\x00\x10\x02\x11\x02\x12\x02\x13\x02\x14\x02\x15\x02\x16\x02\x8e\x02\x8f\x02\x90\x02\x71\x00\x72\x00\x6f\x00\x75\x02\x23\x00\x70\x00\x25\x00\xa4\x02\x93\x02\x94\x02\x7c\x02\x65\x00\xa7\x00\x66\x00\x89\x02\x67\x00\xa8\x00\x68\x00\x69\x00\x6a\x00\x71\x00\x72\x00\xee\x00\x6d\x00\xef\x00\xf0\x00\xcf\x02\xd0\x02\x21\x00\xa9\x00\x8f\x01\xf3\x02\xaa\x00\x08\x02\x09\x02\x0a\x02\x65\x00\xa7\x00\x66\x00\x71\x02\x67\x00\xa8\x00\x68\x00\x69\x00\x6a\x00\x8f\x01\x90\x01\xee\x00\x6d\x00\xef\x00\xf0\x00\x98\x02\x6e\x00\x21\x00\xa9\x00\x9a\x02\x6f\x00\xaa\x00\x81\x02\x70\x00\x25\x00\x8a\x02\xa5\x00\xa6\x00\x4f\xfe\x6f\x00\x4f\xfe\x23\x00\x70\x00\x25\x00\x0d\x02\x09\x02\x0a\x02\xab\x02\x71\x00\x72\x00\x44\x02\x13\x01\x14\x01\x50\xfe\x6e\x00\x50\xfe\x6f\x00\x71\x00\x72\x00\x70\x00\x25\x00\x51\xfe\xf1\x00\x51\xfe\x12\x01\x13\x01\x14\x01\x6f\x00\xad\x02\x23\x00\x70\x00\x25\x00\xf0\x02\x85\x01\x71\x00\x72\x00\x52\xfe\x6f\x00\x52\xfe\xd1\x02\x70\x00\x25\x00\x87\x01\x88\x01\x89\x01\x71\x00\x72\x00\xf1\x00\xeb\x00\x21\x03\xd7\x03\xcd\x01\x68\x00\x69\x00\x6a\x00\x71\x00\x72\x00\x65\x00\x53\xfe\x66\x00\x53\xfe\x67\x00\x92\x01\x68\x00\x69\x00\x6a\x00\x6e\x00\x2d\x04\x6c\x00\x6d\x00\x05\x02\x21\x00\x22\x00\xd6\x01\xb8\x01\x25\x00\x54\xfe\x95\x03\x54\xfe\x6f\x00\xd8\x03\x23\x00\x70\x00\x25\x00\xd1\x00\xd2\x00\xf3\x00\x5b\xfe\xd4\x00\x5b\xfe\xd5\x00\x6e\x00\x0e\x02\x5c\xfe\x2e\x04\x5c\xfe\x16\x02\x71\x00\x72\x00\xb1\x01\x17\x02\xb2\x01\xf2\x00\x0c\x02\x6f\x00\x0d\x02\x23\x00\x70\x00\x25\x00\xd1\x00\xd2\x00\xf3\x00\x1f\x02\xd4\x00\x3a\x02\xd5\x00\x32\x02\xa7\x00\x43\x02\xa1\x00\xb6\x00\xa8\x00\x71\x00\x72\x00\x65\x00\xe4\x00\x66\x00\x40\x02\x67\x00\xb8\x00\x68\x00\x69\x00\x6a\x00\x21\x00\xa9\x00\xe9\x00\x6d\x00\xaa\x00\xa8\x03\x60\x02\xba\x00\x68\x00\x69\x00\x6a\x00\x65\x00\xbb\x00\x66\x00\xe6\x00\x67\x00\x10\x01\x68\x00\x69\x00\x6a\x00\xb3\x00\xb4\x00\xe9\x00\x6d\x00\x4b\x01\xea\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xa9\x03\x65\x00\x63\x04\x66\x00\x5f\x04\x67\x00\x5a\x04\x68\x00\x69\x00\x6a\x00\x5c\x04\x44\x04\x6c\x00\x6d\x00\x5d\x04\x6e\x00\x52\x04\x6f\x00\x84\x01\x85\x01\x70\x00\x25\x00\x42\x02\x43\x02\x4c\x04\xdd\x00\x42\x04\xde\x00\x6f\x00\x41\x04\x23\x00\x70\x00\x25\x00\x03\x02\x04\x02\x71\x00\x72\x00\xe0\x00\xe1\x00\xe2\x00\x42\x02\x43\x02\x64\x03\x65\x03\x2a\x00\x2b\x00\x71\x00\x72\x00\x29\x04\x65\x00\x46\x04\x66\x00\x9c\x02\x67\x00\x48\x04\x68\x00\x69\x00\x6a\x00\xeb\x00\x2a\x04\x6c\x00\x6d\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\x07\x03\x08\x03\x6e\x02\x65\x00\x4a\x04\x66\x00\x03\x02\x67\x00\x49\xff\x68\x00\x69\x00\x6a\x00\x36\x04\x36\x04\x6c\x00\x6d\x00\x6e\x00\x4f\x02\x50\x02\x03\x02\x04\x02\x9a\x02\xdb\x00\x3a\x04\xdc\x00\xdd\x00\x3b\x04\xde\x00\xdf\x00\x6f\x00\x9c\x02\x23\x00\x70\x00\x25\x00\x42\x02\x43\x02\x6e\x00\xe0\x00\xe1\x00\xe2\x00\x6f\x00\xfe\x03\x01\x04\x70\x00\x25\x00\x6e\x02\x0d\x04\x71\x00\x72\x00\x6f\x00\xde\xfd\x23\x00\x70\x00\x25\x00\x18\x04\x1a\x04\x6e\x00\x1d\x04\x71\x00\x72\x00\x19\x04\x6e\x02\x83\x02\xc5\x03\x24\x04\x25\x04\x01\x03\x71\x00\x72\x00\x6f\x00\xca\x03\x23\x00\x70\x00\x25\x00\x65\x00\xcb\x03\x66\x00\xc9\x03\x67\x00\xcc\x03\x68\x00\x69\x00\x6a\x00\xf3\x01\x07\x04\x6c\x00\x6d\x00\x71\x00\x72\x00\xce\x03\x2c\x00\xd3\x03\xd6\x03\xde\x03\xdf\x03\x65\x00\xe2\x03\x66\x00\x42\x03\x67\x00\xf0\x03\x68\x00\x69\x00\x6a\x00\x6e\x00\x0b\x04\x6c\x00\x6d\x00\xf5\x03\xf3\x03\x6e\x02\xcd\x00\xf6\x03\xfc\x03\xce\x00\xfa\x03\xcf\x00\x6f\x00\xd0\x00\x23\x00\x70\x00\x25\x00\x43\x01\x6a\x00\x6e\x00\xd1\x00\xd2\x00\xd3\x00\x6e\x03\xd4\x00\x61\x03\xd5\x00\x71\x03\x6f\x03\x70\x03\x71\x00\x72\x00\x6f\x00\x74\x03\x23\x00\x70\x00\x25\x00\x65\x00\x76\x03\x66\x00\x6e\x02\x67\x00\x75\x03\x68\x00\x69\x00\x6a\x00\x77\x03\xed\x03\x6c\x00\x6d\x00\x71\x00\x72\x00\xe2\x01\x7d\x03\x68\x00\x69\x00\x6a\x00\x65\x00\x8e\x03\x66\x00\x8f\x03\x67\x00\x92\x02\x68\x00\x69\x00\x6a\x00\xd9\x01\x2e\x03\x6c\x00\x6d\x00\x93\x03\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdf\xfd\x97\x03\x65\x00\xa5\x03\x66\x00\xae\x03\x67\x00\xd8\x01\x68\x00\x69\x00\x6a\x00\xf5\x00\x47\x03\x6c\x00\x6d\x00\x6e\x00\x9c\x02\xbc\x03\x2c\x00\xb1\x03\xb1\x01\x02\x03\xee\x00\x05\x03\x6e\x02\xdd\x00\x01\x03\xde\x00\x6f\x00\x0a\x03\x23\x00\x70\x00\x25\x00\xf6\x00\x09\x03\x11\x03\x6e\x00\xe0\x00\xe1\x00\xe2\x00\x22\xff\x12\x03\x13\x03\x9c\x02\x15\x03\x16\x03\x71\x00\x72\x00\x9a\x02\x6f\x00\x1d\x03\x23\x00\x70\x00\x25\x00\x65\x00\x9c\x02\x66\x00\x20\x03\x67\x00\x2e\x03\x68\x00\x69\x00\x6a\x00\xc4\x00\x5f\x02\x6c\x00\x6d\x00\x71\x00\x72\x00\x6f\x00\x33\x03\xc4\x00\x70\x00\x25\x00\x65\x00\x39\x03\x66\x00\x3b\x03\x67\x00\x3c\x03\x68\x00\x69\x00\x6a\x00\x6e\x00\x99\x01\x6c\x00\x6d\x00\x44\x01\x72\x00\x4c\x03\x42\x03\x53\x03\x57\x03\x54\x03\xa3\x00\x5f\x03\x6f\x00\xb6\x00\x23\x00\x70\x00\x25\x00\x4d\x02\x51\x02\x6e\x00\x52\x02\x58\x02\x59\x02\x6f\x00\x5a\x02\x5c\x02\x70\x00\x25\x00\x5d\x02\x5b\x02\x71\x00\x72\x00\x6f\x00\x66\x02\x23\x00\x70\x00\x25\x00\x5e\x02\x5f\x02\x6e\x00\x03\x02\x71\x00\x72\x00\x63\x02\x67\x02\x70\x02\x71\x02\x27\xff\x03\x02\x77\x02\x71\x00\x72\x00\x6f\x00\x83\x02\x23\x00\x70\x00\x25\x00\x65\x00\x0d\x02\x66\x00\x83\x02\x67\x00\x8e\x02\x68\x00\x69\x00\x6a\x00\x9a\x02\xff\x01\x6c\x00\x6d\x00\x71\x00\x72\x00\x92\x02\x9c\x02\xa1\x02\xa7\x02\xa9\x02\x65\x00\xaf\x02\x66\x00\xb6\x02\x67\x00\xb0\x02\x68\x00\x69\x00\x6a\x00\xb3\x02\x04\x02\x6c\x00\x6d\x00\xb9\x02\x6e\x00\xa9\x01\xe0\x02\xe1\x02\xed\x02\xee\x02\xf3\x02\xcd\x00\xf5\x02\x2c\x00\xce\x00\x92\x01\x7e\x01\x6f\x00\xd0\x00\x23\x00\x70\x00\x25\x00\xa8\xfd\xaa\xfd\x6e\x00\xd1\x00\xd2\x00\xd3\x00\xa9\xfd\xd4\x00\xcc\x00\xd5\x00\xac\xfd\xaf\xfd\xa8\x01\x71\x00\x72\x00\x6f\x00\xbb\x01\x23\x00\x70\x00\x25\x00\x65\x00\xa9\x01\x66\x00\xaa\x01\x67\x00\xbc\x01\x68\x00\x69\x00\x6a\x00\xb2\x01\x4c\x01\x6c\x00\x6d\x00\x71\x00\x72\x00\x99\x03\x94\x03\x69\x00\x6a\x00\xc4\x01\x65\x00\xc5\x01\x66\x00\xe9\x00\x67\x00\xc6\x01\x68\x00\x69\x00\x6a\x00\xd6\x01\x6b\x00\x6c\x00\x6d\x00\xcd\x01\xd8\x01\xc7\x01\xc8\x01\xcf\x01\xd9\x01\xe0\x01\x65\x00\xdb\x01\x66\x00\x9a\x03\x67\x00\xe1\x01\x68\x00\x69\x00\x6a\x00\x6e\x00\xe2\x01\x10\x04\x6d\x00\xe9\x01\xea\x01\xeb\x01\xcd\x00\xed\x01\xee\x01\xce\x00\xf4\x01\x44\x03\x6f\x00\xd0\x00\x23\x00\x70\x00\x25\x00\x19\x02\x21\x02\x6e\x00\xd1\x00\xd2\x00\xd3\x00\xb8\x00\xd4\x00\x2b\x02\xd5\x00\x38\x02\x39\x02\x2c\x00\x71\x00\x72\x00\x6f\x00\x3f\x02\x23\x00\x70\x00\x25\x00\x65\x00\xd9\x01\x66\x00\x48\x02\x67\x00\xff\xff\x68\x00\x69\x00\x6a\x00\xa5\x00\xb6\x00\xa1\x02\x6d\x00\x71\x00\x72\x00\xb8\x00\xc6\x00\xc4\x00\xc7\x00\xc8\x00\x65\x00\xe6\x00\x66\x00\x03\x01\x67\x00\xf7\x00\x68\x00\x69\x00\x6a\x00\x04\x01\xff\xff\xa3\x02\x6d\x00\x05\x01\x6e\x00\x08\x01\xff\xff\xff\xff\x7c\x01\xc4\x00\x08\x01\x7d\x01\x04\xfe\xff\xff\xff\xff\xa5\x00\x00\x00\x6f\x00\x00\x00\x23\x00\x70\x00\x25\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x00\x00\x6f\x00\x00\x00\x00\x00\x70\x00\x25\x00\x00\x00\x00\x00\x00\x00\x71\x00\x72\x00\x6f\x00\x00\x00\x23\x00\x70\x00\x25\x00\x00\x00\x00\x00\x6e\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x71\x00\x72\x00\x6f\x00\x00\x00\x23\x00\x70\x00\x25\x00\x65\x00\x00\x00\x66\x00\x00\x00\x67\x00\x00\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\xa5\x02\x6d\x00\x71\x00\x72\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x65\x00\x00\x00\x66\x00\x00\x00\x67\x00\x00\x00\x68\x00\x69\x00\x6a\x00\x6e\x00\x00\x00\xe3\x01\x6d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7c\x02\x00\x00\x00\x00\x00\x00\x6f\x00\x00\x00\x23\x00\x70\x00\x25\x00\x00\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\x71\x00\x72\x00\x6f\x00\x00\x00\x23\x00\x70\x00\x25\x00\x65\x00\x00\x00\x66\x00\x00\x00\x67\x00\x00\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x19\x02\x6d\x00\x71\x00\x72\x00\xbf\x01\x09\x01\x17\x00\x18\x00\x00\x00\x65\x00\x00\x00\x66\x00\x00\x00\x67\x00\x19\x00\x68\x00\x69\x00\x6a\x00\x4d\x00\x00\x00\x1e\x02\x6d\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x65\x00\x57\x00\x66\x00\x00\x00\x67\x00\x00\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x2d\x02\x6d\x00\x5c\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x6f\x00\x00\x00\x23\x00\x70\x00\x25\x00\x62\x00\x00\x00\x6e\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x71\x00\x72\x00\x6f\x00\x26\x00\x23\x00\x70\x00\x25\x00\x65\x00\x00\x00\x66\x00\x00\x00\x67\x00\x00\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\xc4\x00\x6d\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x00\x00\x66\x00\x00\x00\x67\x00\x00\x00\x68\x00\x69\x00\x6a\x00\x6e\x00\x00\x00\xc8\x00\x6d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x00\x00\x23\x00\x70\x00\x25\x00\x00\x00\x00\x00\x6e\x00\x65\x00\xa5\x01\xa6\x01\x00\x00\xbd\x00\x00\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x71\x00\x72\x00\x6f\x00\x00\x00\x23\x00\x70\x00\x25\x00\xbc\x00\x00\x00\x6e\x00\x00\x00\xbd\x00\x00\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x71\x00\x72\x00\x6f\x00\x00\x00\x23\x00\x70\x00\x25\x00\x65\x00\x00\x00\x66\x00\x00\x00\x67\x00\x00\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\xe2\x00\x6d\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x00\x00\x66\x00\x00\x00\x67\x00\x00\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\xf7\x00\x6d\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\x6f\x00\x00\x00\x23\x00\x70\x00\x25\x00\x00\x00\x65\x00\x6e\x00\x28\x02\x00\x00\xbd\x00\x00\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x71\x00\x72\x00\x6f\x00\x00\x00\x23\x00\x70\x00\x25\x00\x00\x00\x65\x00\x00\x00\xe7\x00\x00\x00\xbd\x00\x00\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x6e\x00\x71\x00\x72\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\x23\x00\x70\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf8\x00\x69\x00\x6a\x00\xf9\x00\x00\x00\x6f\x00\x71\x00\x72\x00\x70\x00\x25\x00\x21\x03\x22\x03\x6e\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x23\x03\x00\x00\x00\x00\x00\x00\x71\x00\x72\x00\x6f\x00\x00\x00\x23\x00\x70\x00\x25\x00\x21\x03\x9d\x03\x6e\x00\x68\x00\x69\x00\x6a\x00\x00\x00\x24\x03\x25\x03\x26\x03\x00\x00\x27\x03\x00\x00\x71\x00\x72\x00\x6f\x00\x00\x00\x23\x00\x70\x00\x25\x00\x00\x00\x00\x00\x46\x04\x94\x03\x69\x00\x6a\x00\x00\x00\x9e\x03\x25\x03\x26\x03\x00\x00\x27\x03\x00\x00\x71\x00\x72\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x2b\x04\x94\x03\x69\x00\x6a\x00\x00\x00\x2c\x04\x94\x03\x69\x00\x6a\x00\x6f\x00\x00\x00\x23\x00\x70\x00\x25\x00\x00\x00\x00\x00\x6e\x00\x13\x04\x94\x03\x69\x00\x6a\x00\x00\x00\xd3\x03\x94\x03\x69\x00\x6a\x00\x00\x00\x71\x00\x72\x00\x6f\x00\x00\x00\x23\x00\x70\x00\x25\x00\xd6\x03\x94\x03\x69\x00\x6a\x00\x00\x00\x93\x03\x94\x03\x69\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfa\x00\x00\x00\x00\x00\x00\x00\xd0\x00\x00\x00\x6f\x00\x00\x00\x28\x03\x70\x00\x25\x00\xd1\x00\xd2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x00\x00\x00\x00\x29\x03\x25\x00\x71\x00\x72\x00\xfb\x00\xfc\x00\x28\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x71\x00\x72\x00\x6f\x00\x00\x00\x00\x00\x29\x03\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x71\x00\x72\x00\x6f\x00\x00\x00\x00\x00\x70\x00\x25\x00\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\x71\x00\x72\x00\x70\x00\x25\x00\x6f\x00\x00\x00\x00\x00\x70\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x71\x00\x72\x00\x70\x00\x25\x00\x6f\x00\x71\x00\x72\x00\x70\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x71\x00\x72\x00\x70\x00\x25\x00\x6f\x00\x71\x00\x72\x00\x70\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x71\x00\x72\x00\x00\x00\x00\x00\x00\x00\x71\x00\x72\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x6e\x02\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\xcc\x00\x58\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x5e\x03\x00\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x5f\x00\x00\x00\x90\x00\x00\x00\x60\x00\x00\x00\x00\x00\x91\x00\x00\x00\x00\x00\x62\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\x00\x96\x00\x63\x00\x64\x00\x65\x00\x97\x00\x98\x00\x00\x00\x00\x00\x00\x00\x99\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\xcd\x00\x39\x00\x00\x00\xce\x00\x00\x00\xcf\x00\x00\x00\xd0\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\xd1\x00\xd2\x00\xd3\x00\x00\x00\xd4\x00\x3c\x00\xd5\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x58\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x5e\x03\x00\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x5f\x00\x00\x00\x90\x00\x00\x00\x60\x00\x00\x00\x00\x00\x91\x00\x00\x00\x00\x00\x62\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\x00\x96\x00\x63\x00\x64\x00\x65\x00\x97\x00\x98\x00\x00\x00\x00\x00\x00\x00\x99\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x58\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x5f\x00\x28\x00\x90\x00\x00\x00\x60\x00\x2c\x00\x2d\x00\x91\x00\x00\x00\x40\xff\x62\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\x00\x96\x00\x63\x00\x64\x00\x65\x00\x97\x00\x98\x00\x74\x00\x00\x00\x75\x00\x99\x00\x28\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x76\x00\x00\x00\x00\x00\x00\x00\x40\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x03\x02\x01\x00\x00\xa1\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\x28\x00\x00\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x74\x00\x57\x00\x75\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x76\x00\x00\x00\x40\xff\x5c\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x74\x00\x57\x00\x75\x00\x30\x04\x00\x00\x00\x00\x00\x00\x62\x00\x00\x00\x00\x00\x76\x00\x00\x00\x00\x00\x5c\x00\x40\xff\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x03\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x03\x00\x00\x00\x00\x00\x00\x62\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x7b\x02\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x7c\x02\x57\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x7a\x00\x00\x00\x5c\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x74\x00\x57\x00\x75\x00\x00\x00\x28\x00\x00\x00\x00\x00\x62\x00\x2c\x00\x2d\x00\x76\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x74\x00\x00\x00\x75\x00\x2c\x03\x00\x00\x00\x00\x00\x00\x62\x00\x4d\x00\x00\x00\x76\x00\x00\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\xa2\x03\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x03\x00\x00\x00\x00\x00\x00\x5c\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x62\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x2b\x03\x57\x00\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x00\x00\x00\x00\x76\x00\x00\x00\x00\x00\x5c\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\x00\x00\x2d\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x03\x00\x00\x00\x00\x00\x00\x62\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdb\x00\x00\x00\xdc\x00\xdd\x00\x9d\x03\xde\x00\xdf\x00\xc6\xfe\x00\x00\xc6\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\x00\xe1\x00\xe2\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x5c\x00\x63\x01\xd8\x00\xd9\x00\xda\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\xe5\x02\x62\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\xb0\x01\x3b\x00\x65\x01\x66\x01\x2d\x03\xde\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x67\x01\x68\x01\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x63\x00\x64\x00\x65\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x63\x01\xd8\x00\xd9\x00\xda\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\xec\x02\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\xb0\x01\x3b\x00\x65\x01\x66\x01\x00\x00\xde\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x67\x01\x68\x01\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x63\x00\x64\x00\x65\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x63\x01\xd8\x00\xd9\x00\xda\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\xaf\x01\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\xb0\x01\x3b\x00\x65\x01\x66\x01\x00\x00\xde\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x67\x01\x68\x01\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x63\x00\x64\x00\x65\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x63\x01\xd8\x00\xd9\x00\xda\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\xb7\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\xb0\x01\x3b\x00\x65\x01\x66\x01\x00\x00\xde\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x67\x01\x68\x01\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x63\x00\x64\x00\x65\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x63\x01\xd8\x00\xd9\x00\xda\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x6b\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\xee\x00\x3b\x00\x65\x01\x66\x01\x00\x00\xde\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x67\x01\x68\x01\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x63\x00\x64\x00\x65\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x73\x01\xd8\x00\xd9\x00\xda\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x74\x01\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\xee\x00\x3b\x00\x65\x01\x75\x01\x00\x00\xde\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x76\x01\x77\x01\x78\x01\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x63\x00\x64\x00\x65\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x63\x01\xd8\x00\xd9\x00\xda\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x64\x01\x00\x00\x3b\x00\x65\x01\x66\x01\x00\x00\xde\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x67\x01\x68\x01\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x63\x00\x64\x00\x65\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x63\x01\xd8\x00\xd9\x00\xda\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x65\x01\x66\x01\x00\x00\xde\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x67\x01\x68\x01\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x63\x00\x64\x00\x65\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\xde\x01\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x60\x00\x61\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x63\x00\x64\x00\x65\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x6e\x02\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x63\x00\x64\x00\x65\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x02\x5f\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\xdb\x02\x00\x00\x00\x00\x00\x00\x62\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x63\x00\x64\x00\x65\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x60\x00\x61\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x63\x00\x64\x00\x65\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x63\x00\x64\x00\x65\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x02\x5f\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x63\x00\x64\x00\x65\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x03\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x63\x00\x64\x00\x65\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x02\x5f\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x63\x00\x64\x00\x65\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x63\x00\x64\x00\x65\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x63\x00\x64\x00\x65\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x6e\x02\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x58\x00\x00\x00\xe7\x03\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x8b\x00\x8c\x00\x8d\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe8\x03\x00\x00\x00\x00\x62\x00\x92\x00\x93\x00\x94\x00\x95\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x58\x00\x00\x00\xe7\x03\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x8b\x00\x8c\x00\x8d\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe8\x03\x00\x00\x00\x00\x62\x00\x92\x00\x93\x00\x94\x00\x95\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x6e\x02\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x58\x00\x00\x00\x85\x03\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x56\x01\x57\x01\x09\x01\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x90\x00\x19\x00\x00\x00\x00\x00\x00\x00\x86\x03\x00\x00\x00\x00\x62\x00\x92\x00\x93\x00\x94\x00\x95\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x1c\x00\x39\x00\x00\x00\x1d\x00\x1e\x00\x6e\x02\x1f\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x85\x00\x00\x00\x26\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x9b\x01\x57\x00\x15\x00\x58\x00\x00\x00\x16\x00\x17\x00\x18\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x19\x00\x00\x00\x00\x00\x8b\x00\x8c\x00\x8d\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x62\x00\x92\x00\x93\x00\x94\x00\x95\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x1c\x00\x39\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x85\x00\x00\x00\x26\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x58\x00\x00\x00\x85\x03\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x54\x01\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x5f\x00\x00\x00\x90\x00\x00\x00\x00\x00\x19\x00\x00\x00\x86\x03\x00\x00\x00\x00\x62\x00\x92\x00\x93\x00\x94\x00\x95\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x3d\x00\x00\x00\x3e\x00\x85\x00\x00\x00\x00\x00\x00\x00\x26\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x8b\x00\x8c\x00\x8d\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x92\x00\x93\x00\x94\x00\x95\x00\xbe\x02\x29\x00\x2a\x00\x2b\x00\xbf\x02\x2d\x00\x18\x01\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x01\xc0\x02\xc1\x02\xc2\x02\xc3\x02\x00\x00\xc4\x02\xc5\x02\xc6\x02\xc7\x02\xc8\x02\xc9\x02\x00\x00\xca\x02\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\x2c\x01\xcb\x02\xcc\x02\x2f\x01\xcd\x02\x31\x01\x32\x01\x33\x01\x34\x01\x35\x01\x36\x01\x37\x01\x38\x01\x39\x01\x3a\x01\x3b\x01\x3c\x01\x3d\x01\x3e\x01\x3f\x01\x40\x01\x41\x01\x42\x01\xce\x02\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x62\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\x01\x00\x00\x3d\x00\x00\x00\x00\x00\x0b\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x08\x01\x09\x01\x17\x00\x18\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x19\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x62\x00\x1f\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x3d\x00\x00\x00\x00\x00\x0b\x01\x00\x00\x00\x00\x00\x00\x26\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\xb4\x03\x17\x00\x18\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x19\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x00\x00\x39\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x62\x00\x1f\x00\x3a\x00\x16\x01\x00\x00\x3b\x00\x00\x00\x17\x01\x00\x00\x18\x01\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x00\x00\x47\x00\x48\x00\x49\x00\x00\x00\x4a\x00\x00\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x00\x00\x1e\x01\x1f\x01\x20\x01\x21\x01\x22\x01\x23\x01\x62\x00\x24\x01\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\x2c\x01\x2d\x01\x2e\x01\x2f\x01\x30\x01\x31\x01\x32\x01\x33\x01\x34\x01\x35\x01\x36\x01\x37\x01\x38\x01\x39\x01\x3a\x01\x3b\x01\x3c\x01\x3d\x01\x3e\x01\x3f\x01\x40\x01\x41\x01\x42\x01\x43\x01\x28\x00\x00\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\x52\x02\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x74\x00\xf5\x00\x75\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\x00\x00\x00\x00\x00\x00\x76\x00\x00\x00\xee\x00\x00\x00\x00\x00\xdd\x00\x00\x00\xde\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x00\x00\x00\x00\x00\x00\x00\xe0\x00\xe1\x00\xe2\x00\x00\x00\xdc\x00\xdd\x00\x1c\x00\xde\x00\xeb\x03\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\x00\xe1\x00\xe2\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x26\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x28\x00\x57\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\xfe\x00\xd8\x00\x00\x00\xda\x00\x7a\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x74\x00\x00\x00\x75\x00\x2c\x00\x2d\x00\x00\x00\xfe\x00\xd8\x00\x00\x00\xda\x00\x76\x00\x62\x00\x00\x00\x00\x00\xff\x00\x00\x00\x00\x00\xde\x00\x00\x00\x00\x00\x74\x00\x00\x00\x75\x00\x00\x01\x00\x00\x01\x01\x02\x01\x00\x00\x00\x00\x00\x00\x76\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\x00\x00\xde\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x2a\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\x4d\x00\x77\x00\x78\x00\x79\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x28\x00\x00\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x5c\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x74\x00\x00\x00\x75\x00\xed\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x5c\x00\x76\x00\x28\x00\xee\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x00\x00\x00\x00\x00\x00\x74\x00\xab\x03\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x76\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x74\x00\x00\x00\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7a\x00\x76\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x28\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x62\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x5c\x00\x51\x03\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x62\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x74\x00\x57\x00\x75\x00\x00\x00\x28\x00\x29\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x76\x00\x7a\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x6c\x03\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x28\x00\x00\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x74\x00\x57\x00\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x00\x00\x00\x00\x76\x00\x7a\x00\x00\x00\x5c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x00\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x29\x00\x00\x00\x6d\x03\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x28\x00\x00\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x5c\x00\x00\x00\x28\x00\x00\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x74\x00\x00\x00\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x76\x00\xe9\x00\x00\x00\x74\x00\x00\x00\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x76\x00\x28\x00\x29\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x4b\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x62\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x5c\x00\x57\x00\x00\x00\x28\x00\x29\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x62\x00\x57\x00\x00\x00\x28\x00\x00\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x6d\x03\x74\x00\x00\x00\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x00\x00\x76\x00\x00\x00\x00\x00\x74\x00\x00\x00\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x76\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x62\x00\x57\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x5c\x00\x57\x00\x28\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\xbf\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\xc0\x00\x00\x00\x00\x00\xac\x00\x61\x04\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x62\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\x06\x04\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x74\x00\x00\x00\x75\x00\x2c\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x76\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\xac\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa8\x02\x5a\x00\x5b\x00\x00\x00\x5c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x62\x00\x00\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x62\x00\x00\x00\x28\x00\x29\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x5c\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x3e\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x01\x00\x00\x5a\x00\x5b\x00\x62\x00\x5c\x00\x28\x00\x00\x00\xa1\x01\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\xa2\x01\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x62\x00\x00\x00\x00\x00\xac\x00\x00\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x29\x00\x00\x00\x5c\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x4b\x01\x62\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x5a\x00\x5b\x00\x2c\x00\x5c\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\xac\x00\x00\x00\x00\x00\x62\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x6c\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\x00\x00\x00\x00\x00\x00\x28\x00\x29\x00\xae\x00\x00\x00\x00\x00\x62\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\xa0\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x5b\x00\xdd\x03\x5c\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x28\x00\x00\x00\x00\x00\x62\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x74\x00\x00\x00\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x76\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x28\x00\x57\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x74\x00\x00\x00\x75\x00\x00\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x76\x00\x62\x00\x00\x00\x00\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\xa0\x01\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x5c\x00\x00\x00\x00\x00\xa2\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x74\x00\x00\x00\x75\x00\x00\x00\x00\x00\x62\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x76\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x5c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x74\x00\x00\x00\x75\x00\x00\x00\x00\x00\x62\x00\x00\x00\x00\x00\x5a\x00\x5b\x00\x76\x00\x5c\x00\x00\x00\x00\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x62\x00\x28\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x5c\x00\x00\x00\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\x75\x00\x00\x00\x00\x00\x62\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x76\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x46\x01\x00\x00\x47\x01\x00\x00\x00\x00\x62\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x01\x00\x00\x00\x00\xac\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x01\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x5c\x00\x57\x00\x28\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x00\x00\x00\x00\x00\x00\xac\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x62\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\xac\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x03\x4d\x00\x4e\x00\x4f\x00\x50\x00\x62\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x62\x00\x57\x00\x00\x00\x51\x03\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x5a\x00\x5b\x00\x2c\x00\x5c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x28\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x28\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\xf7\x01\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\xa3\x03\x00\x00\x00\x00\x62\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x62\x00\x00\x00\x00\x00\x5a\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x1d\xff\x00\x00\x00\x00\x00\x00\x4d\x00\x77\x00\x78\x00\x79\x00\xf7\x01\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x62\x00\x57\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\x00\x00\x00\x00\xf8\x01\x00\x00\x00\x00\x28\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdc\x00\xdd\x00\x62\x00\xde\x00\x80\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\x00\xe1\x00\xe2\x00\x81\x01\x82\x01\x83\x01\x84\x01\x00\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x00\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x1d\xff\x1d\xff\x1d\xff\x1d\xff\x00\x00\x1d\xff\x1d\xff\x1d\xff\x1d\xff\x1d\xff\x1d\xff\x5c\x00\x1d\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1d\xff\x00\x00\x4d\x00\x77\x00\x78\x00\x79\x00\x62\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1d\xff\x83\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x5c\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x62\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\x02\xd6\x02\xd7\x02\xd8\x02\x00\x00\xd9\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x83\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x03\xd7\x02\xd8\x02\x00\x00\xd9\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x83\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb8\x03\xd8\x02\x00\x00\xd9\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x83\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x04\x85\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1a\x00\x00\x00\x0f\x03\x00\x00\xdc\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x83\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x02\x85\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1a\x00\x00\x00\xac\x02\x00\x00\xdc\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x83\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd2\x02\x85\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1a\x00\x00\x00\xdb\x01\x00\x00\xdc\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1a\x00\x00\x00\xde\x01\x00\x00\xdc\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x83\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x04\x9c\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x1a\x00\x00\x00\x00\x00\x19\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x26\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x25\x04\x9c\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x1f\x04\x9c\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x26\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xbd\x03\x9c\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\xbe\x03\x9c\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x26\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xbf\x03\x9c\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\xf0\x03\x9c\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x26\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x7a\x03\x9c\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x8f\x03\x9c\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x26\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x90\x03\x9c\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\xfe\x02\x9c\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x26\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x88\x02\x9c\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\xa2\x01\x9c\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x26\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x4f\x01\x9c\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x50\x01\x9c\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x26\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x9b\x00\x9c\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x6b\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x6c\x01\x6d\x01\x00\x00\x00\x00\x00\x00\x6e\x01\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x5c\x01\x00\x00\x5d\x01\x00\x00\x00\x00\x5e\x01\x6f\x01\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xd1\x00\xd2\x00\x70\x01\x5f\x01\xd4\x00\x60\x01\x71\x01\x26\x00\x58\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x59\x01\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x01\x5b\x01\x58\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x68\x01\x69\x01\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x5c\x01\x00\x00\x5d\x01\x00\x00\x00\x00\x5e\x01\xd0\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xd1\x00\xd2\x00\x00\x00\x5f\x01\x00\x00\x60\x01\x61\x01\x26\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x5c\x01\x00\x00\x5d\x01\x00\x00\x00\x00\x5e\x01\xd0\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xd1\x00\xd2\x00\x00\x00\x5f\x01\x00\x00\x60\x01\x61\x01\x26\x00\xdc\x02\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\xdd\x02\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\xde\x02\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x5c\x01\x00\x00\x5d\x01\x00\x00\x00\x00\x5e\x01\xd0\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xd1\x00\xd2\x00\x00\x00\x5f\x01\x00\x00\x60\x01\x61\x01\x26\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x5c\x01\x00\x00\x5d\x01\x00\x00\x00\x00\x5e\x01\xd0\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xd1\x00\xd2\x00\x00\x00\x5f\x01\x00\x00\x60\x01\x61\x01\x26\x00\x58\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\xe3\x02\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\xea\x02\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x5c\x01\x00\x00\x5d\x01\x00\x00\x00\x00\x5e\x01\xd0\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xd1\x00\xd2\x00\x00\x00\x5f\x01\x00\x00\x60\x01\x61\x01\x26\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x5c\x01\x00\x00\x5d\x01\x00\x00\x00\x00\x5e\x01\xd0\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xd1\x00\xd2\x00\x00\x00\x5f\x01\x00\x00\x60\x01\x61\x01\x26\x00\x58\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\xad\x01\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\xb5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x5c\x01\x00\x00\x5d\x01\x00\x00\x00\x00\x5e\x01\xd0\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xd1\x00\xd2\x00\x00\x00\x5f\x01\x00\x00\x60\x01\x61\x01\x26\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x5c\x01\x00\x00\x5d\x01\x00\x00\x00\x00\x5e\x01\xd0\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xd1\x00\xd2\x00\x00\x00\x5f\x01\x00\x00\x60\x01\x61\x01\x26\x00\x99\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x99\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\xb1\x03\xb2\x03\x00\x00\x19\x00\x00\x00\xb3\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x1e\x04\x00\x00\x00\x00\x00\x00\xb3\x03\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\xb6\x02\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x02\x00\x00\x19\x00\xe6\x02\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe7\x02\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x51\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x52\x01\x00\x00\x19\x00\x99\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9a\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x4a\x04\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x1d\x04\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\xbc\x03\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\xf8\x02\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x0e\x03\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\xa9\x02\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\xaa\x02\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\xb0\x02\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\xb1\x02\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\xd3\x02\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\xd4\x02\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\xdb\x02\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\xe5\x02\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x95\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x96\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x97\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x98\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x0d\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x0f\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x11\x01\x0f\x00\x10\x00\x11\x00\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x51\x03\x10\x00\x4e\x01\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\xb9\x01\x10\x00\x4e\x01\x12\x00\x00\x00\x00\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x9a\x01\x1f\x00\x26\x00\x9b\x01\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x19\x00\x00\x00\x4d\x01\x10\x00\x4e\x01\x12\x00\x00\x00\x26\x00\x13\x00\x14\x00\x15\x00\x00\x00\x00\x00\x16\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xb9\x02\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x00\x00\x19\x00\x00\x00\x00\x00\xba\x02\x13\x01\x14\x01\x00\x00\xbb\x02\x58\x03\x00\x00\x00\x00\x00\x00\x00\x00\xb9\x02\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\xba\x02\x13\x01\x14\x01\x00\x00\xbb\x02\xbc\x02\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x01\x17\x00\x18\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x01\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7d\x01\x17\x00\x18\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd9\x01\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3b\x02\x17\x00\x18\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3f\x02\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcb\x00\x17\x00\x18\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x01\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x01\x17\x00\x18\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7d\x01\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x1c\x00\x00\x00\x00\x00\x1d\x00\x1e\x00\x00\x00\x1f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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 (8, 629) [+	(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),+	(371 , happyReduce_371),+	(372 , happyReduce_372),+	(373 , happyReduce_373),+	(374 , happyReduce_374),+	(375 , happyReduce_375),+	(376 , happyReduce_376),+	(377 , happyReduce_377),+	(378 , happyReduce_378),+	(379 , happyReduce_379),+	(380 , happyReduce_380),+	(381 , happyReduce_381),+	(382 , happyReduce_382),+	(383 , happyReduce_383),+	(384 , happyReduce_384),+	(385 , happyReduce_385),+	(386 , happyReduce_386),+	(387 , happyReduce_387),+	(388 , happyReduce_388),+	(389 , happyReduce_389),+	(390 , happyReduce_390),+	(391 , happyReduce_391),+	(392 , happyReduce_392),+	(393 , happyReduce_393),+	(394 , happyReduce_394),+	(395 , happyReduce_395),+	(396 , happyReduce_396),+	(397 , happyReduce_397),+	(398 , happyReduce_398),+	(399 , happyReduce_399),+	(400 , happyReduce_400),+	(401 , happyReduce_401),+	(402 , happyReduce_402),+	(403 , happyReduce_403),+	(404 , happyReduce_404),+	(405 , happyReduce_405),+	(406 , happyReduce_406),+	(407 , happyReduce_407),+	(408 , happyReduce_408),+	(409 , happyReduce_409),+	(410 , happyReduce_410),+	(411 , happyReduce_411),+	(412 , happyReduce_412),+	(413 , happyReduce_413),+	(414 , happyReduce_414),+	(415 , happyReduce_415),+	(416 , happyReduce_416),+	(417 , happyReduce_417),+	(418 , happyReduce_418),+	(419 , happyReduce_419),+	(420 , happyReduce_420),+	(421 , happyReduce_421),+	(422 , happyReduce_422),+	(423 , happyReduce_423),+	(424 , happyReduce_424),+	(425 , happyReduce_425),+	(426 , happyReduce_426),+	(427 , happyReduce_427),+	(428 , happyReduce_428),+	(429 , happyReduce_429),+	(430 , happyReduce_430),+	(431 , happyReduce_431),+	(432 , happyReduce_432),+	(433 , happyReduce_433),+	(434 , happyReduce_434),+	(435 , happyReduce_435),+	(436 , happyReduce_436),+	(437 , happyReduce_437),+	(438 , happyReduce_438),+	(439 , happyReduce_439),+	(440 , happyReduce_440),+	(441 , happyReduce_441),+	(442 , happyReduce_442),+	(443 , happyReduce_443),+	(444 , happyReduce_444),+	(445 , happyReduce_445),+	(446 , happyReduce_446),+	(447 , happyReduce_447),+	(448 , happyReduce_448),+	(449 , happyReduce_449),+	(450 , happyReduce_450),+	(451 , happyReduce_451),+	(452 , happyReduce_452),+	(453 , happyReduce_453),+	(454 , happyReduce_454),+	(455 , happyReduce_455),+	(456 , happyReduce_456),+	(457 , happyReduce_457),+	(458 , happyReduce_458),+	(459 , happyReduce_459),+	(460 , happyReduce_460),+	(461 , happyReduce_461),+	(462 , happyReduce_462),+	(463 , happyReduce_463),+	(464 , happyReduce_464),+	(465 , happyReduce_465),+	(466 , happyReduce_466),+	(467 , happyReduce_467),+	(468 , happyReduce_468),+	(469 , happyReduce_469),+	(470 , happyReduce_470),+	(471 , happyReduce_471),+	(472 , happyReduce_472),+	(473 , happyReduce_473),+	(474 , happyReduce_474),+	(475 , happyReduce_475),+	(476 , happyReduce_476),+	(477 , happyReduce_477),+	(478 , happyReduce_478),+	(479 , happyReduce_479),+	(480 , happyReduce_480),+	(481 , happyReduce_481),+	(482 , happyReduce_482),+	(483 , happyReduce_483),+	(484 , happyReduce_484),+	(485 , happyReduce_485),+	(486 , happyReduce_486),+	(487 , happyReduce_487),+	(488 , happyReduce_488),+	(489 , happyReduce_489),+	(490 , happyReduce_490),+	(491 , happyReduce_491),+	(492 , happyReduce_492),+	(493 , happyReduce_493),+	(494 , happyReduce_494),+	(495 , happyReduce_495),+	(496 , happyReduce_496),+	(497 , happyReduce_497),+	(498 , happyReduce_498),+	(499 , happyReduce_499),+	(500 , happyReduce_500),+	(501 , happyReduce_501),+	(502 , happyReduce_502),+	(503 , happyReduce_503),+	(504 , happyReduce_504),+	(505 , happyReduce_505),+	(506 , happyReduce_506),+	(507 , happyReduce_507),+	(508 , happyReduce_508),+	(509 , happyReduce_509),+	(510 , happyReduce_510),+	(511 , happyReduce_511),+	(512 , happyReduce_512),+	(513 , happyReduce_513),+	(514 , happyReduce_514),+	(515 , happyReduce_515),+	(516 , happyReduce_516),+	(517 , happyReduce_517),+	(518 , happyReduce_518),+	(519 , happyReduce_519),+	(520 , happyReduce_520),+	(521 , happyReduce_521),+	(522 , happyReduce_522),+	(523 , happyReduce_523),+	(524 , happyReduce_524),+	(525 , happyReduce_525),+	(526 , happyReduce_526),+	(527 , happyReduce_527),+	(528 , happyReduce_528),+	(529 , happyReduce_529),+	(530 , happyReduce_530),+	(531 , happyReduce_531),+	(532 , happyReduce_532),+	(533 , happyReduce_533),+	(534 , happyReduce_534),+	(535 , happyReduce_535),+	(536 , happyReduce_536),+	(537 , happyReduce_537),+	(538 , happyReduce_538),+	(539 , happyReduce_539),+	(540 , happyReduce_540),+	(541 , happyReduce_541),+	(542 , happyReduce_542),+	(543 , happyReduce_543),+	(544 , happyReduce_544),+	(545 , happyReduce_545),+	(546 , happyReduce_546),+	(547 , happyReduce_547),+	(548 , happyReduce_548),+	(549 , happyReduce_549),+	(550 , happyReduce_550),+	(551 , happyReduce_551),+	(552 , happyReduce_552),+	(553 , happyReduce_553),+	(554 , happyReduce_554),+	(555 , happyReduce_555),+	(556 , happyReduce_556),+	(557 , happyReduce_557),+	(558 , happyReduce_558),+	(559 , happyReduce_559),+	(560 , happyReduce_560),+	(561 , happyReduce_561),+	(562 , happyReduce_562),+	(563 , happyReduce_563),+	(564 , happyReduce_564),+	(565 , happyReduce_565),+	(566 , happyReduce_566),+	(567 , happyReduce_567),+	(568 , happyReduce_568),+	(569 , happyReduce_569),+	(570 , happyReduce_570),+	(571 , happyReduce_571),+	(572 , happyReduce_572),+	(573 , happyReduce_573),+	(574 , happyReduce_574),+	(575 , happyReduce_575),+	(576 , happyReduce_576),+	(577 , happyReduce_577),+	(578 , happyReduce_578),+	(579 , happyReduce_579),+	(580 , happyReduce_580),+	(581 , happyReduce_581),+	(582 , happyReduce_582),+	(583 , happyReduce_583),+	(584 , happyReduce_584),+	(585 , happyReduce_585),+	(586 , happyReduce_586),+	(587 , happyReduce_587),+	(588 , happyReduce_588),+	(589 , happyReduce_589),+	(590 , happyReduce_590),+	(591 , happyReduce_591),+	(592 , happyReduce_592),+	(593 , happyReduce_593),+	(594 , happyReduce_594),+	(595 , happyReduce_595),+	(596 , happyReduce_596),+	(597 , happyReduce_597),+	(598 , happyReduce_598),+	(599 , happyReduce_599),+	(600 , happyReduce_600),+	(601 , happyReduce_601),+	(602 , happyReduce_602),+	(603 , happyReduce_603),+	(604 , happyReduce_604),+	(605 , happyReduce_605),+	(606 , happyReduce_606),+	(607 , happyReduce_607),+	(608 , happyReduce_608),+	(609 , happyReduce_609),+	(610 , happyReduce_610),+	(611 , happyReduce_611),+	(612 , happyReduce_612),+	(613 , happyReduce_613),+	(614 , happyReduce_614),+	(615 , happyReduce_615),+	(616 , happyReduce_616),+	(617 , happyReduce_617),+	(618 , happyReduce_618),+	(619 , happyReduce_619),+	(620 , happyReduce_620),+	(621 , happyReduce_621),+	(622 , happyReduce_622),+	(623 , happyReduce_623),+	(624 , happyReduce_624),+	(625 , happyReduce_625),+	(626 , happyReduce_626),+	(627 , happyReduce_627),+	(628 , happyReduce_628),+	(629 , happyReduce_629)+	]++happy_n_terms = 141 :: Int+happy_n_nonterms = 223 :: Int++happyReduce_8 = happySpecReduce_2  0# happyReduction_8+happyReduction_8 happy_x_2+	happy_x_1+	 =  case happyOut15 happy_x_1 of { happy_var_1 -> +	case happyOut12 happy_x_2 of { happy_var_2 -> +	happyIn11+		 (let (os,ss,l) = happy_var_1 in map (\x -> x os ss l) happy_var_2+	)}}++happyReduce_9 = happySpecReduce_2  1# happyReduction_9+happyReduction_9 happy_x_2+	happy_x_1+	 =  case happyOut19 happy_x_1 of { happy_var_1 -> +	case happyOut12 happy_x_2 of { happy_var_2 -> +	happyIn12+		 (happy_var_1 : happy_var_2+	)}}++happyReduce_10 = happySpecReduce_1  1# happyReduction_10+happyReduction_10 happy_x_1+	 =  case happyOut19 happy_x_1 of { happy_var_1 -> +	happyIn12+		 ([happy_var_1]+	)}++happyReduce_11 = happyMonadReduce 2# 2# happyReduction_11+happyReduction_11 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut15 happy_x_1 of { happy_var_1 -> +	case happyOut14 happy_x_2 of { happy_var_2 -> +	( checkPageModule happy_var_2 happy_var_1)}}+	) (\r -> happyReturn (happyIn13 r))++happyReduce_12 = happyMonadReduce 5# 2# happyReduction_12+happyReduction_12 (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_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 XCodeTagOpen) -> +	case happyOut19 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (Loc happy_var_4 XCodeTagClose) -> +	case happyOut14 happy_x_5 of { happy_var_5 -> +	( let (os,ss,l) = happy_var_1 in checkHybridModule happy_var_5 (happy_var_3 os ss l) happy_var_2 happy_var_4)}}}}}+	) (\r -> happyReturn (happyIn13 r))++happyReduce_13 = happySpecReduce_2  2# happyReduction_13+happyReduction_13 happy_x_2+	happy_x_1+	 =  case happyOut15 happy_x_1 of { happy_var_1 -> +	case happyOut19 happy_x_2 of { happy_var_2 -> +	happyIn13+		 (let (os,ss,l) = happy_var_1 in happy_var_2 os ss l+	)}}++happyReduce_14 = happyMonadReduce 9# 3# happyReduction_14+happyReduction_14 (happy_x_9 `HappyStk`+	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) tk+	 = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 XStdTagOpen) -> +	case happyOut164 happy_x_2 of { happy_var_2 -> +	case happyOut167 happy_x_3 of { happy_var_3 -> +	case happyOut169 happy_x_4 of { happy_var_4 -> +	case happyOutTok happy_x_5 of { (Loc happy_var_5 XStdTagClose) -> +	case happyOut162 happy_x_6 of { happy_var_6 -> +	case happyOutTok happy_x_7 of { (Loc happy_var_7 XCloseTagOpen) -> +	case happyOut164 happy_x_8 of { happy_var_8 -> +	case happyOutTok happy_x_9 of { (Loc happy_var_9 XStdTagClose) -> +	( do { n <- checkEqNames happy_var_2 happy_var_8;+                                                                       let { cn = reverse happy_var_6;+                                                                             as = reverse happy_var_3; };+                                                                       return $ XTag (happy_var_1 <^^> happy_var_9 <** [happy_var_1,happy_var_5,happy_var_7,happy_var_9]) n as happy_var_4 cn })}}}}}}}}}+	) (\r -> happyReturn (happyIn14 r))++happyReduce_15 = happyReduce 5# 3# happyReduction_15+happyReduction_15 (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 { (Loc happy_var_1 XStdTagOpen) -> +	case happyOut164 happy_x_2 of { happy_var_2 -> +	case happyOut167 happy_x_3 of { happy_var_3 -> +	case happyOut169 happy_x_4 of { happy_var_4 -> +	case happyOutTok happy_x_5 of { (Loc happy_var_5 XEmptyTagClose) -> +	happyIn14+		 (XETag (happy_var_1 <^^> happy_var_5 <** [happy_var_1,happy_var_5]) happy_var_2 (reverse happy_var_3) happy_var_4+	) `HappyStk` happyRest}}}}}++happyReduce_16 = happySpecReduce_3  4# happyReduction_16+happyReduction_16 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut225 happy_x_1 of { happy_var_1 -> +	case happyOut16 happy_x_2 of { happy_var_2 -> +	case happyOut226 happy_x_3 of { happy_var_3 -> +	happyIn15+		 (let (os,ss,ml) = happy_var_2 in (os,happy_var_1:ss++[happy_var_3],happy_var_1 <^^> happy_var_3)+	)}}}++happyReduce_17 = happySpecReduce_3  5# happyReduction_17+happyReduction_17 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut17 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 SemiColon) -> +	case happyOut16 happy_x_3 of { happy_var_3 -> +	happyIn16+		 (let (os,ss,ml) = happy_var_3 in (happy_var_1 : os, happy_var_2 : ss, Just $ ann happy_var_1 <++> nIS happy_var_2 <+?> ml)+	)}}}++happyReduce_18 = happySpecReduce_0  5# happyReduction_18+happyReduction_18  =  happyIn16+		 (([],[],Nothing)+	)++happyReduce_19 = happyReduce 4# 6# happyReduction_19+happyReduction_19 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 LANGUAGE) -> +	case happyOut18 happy_x_2 of { happy_var_2 -> +	case happyOut25 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (Loc happy_var_4 PragmaEnd) -> +	happyIn17+		 (LanguagePragma (happy_var_1 <^^> happy_var_4 <** (happy_var_1:snd happy_var_2 ++ reverse happy_var_3 ++ [happy_var_4])) (fst happy_var_2)+	) `HappyStk` happyRest}}}}++happyReduce_20 = happySpecReduce_3  6# happyReduction_20+happyReduction_20 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut25 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 PragmaEnd) -> +	happyIn17+		 (let Loc l (OPTIONS (mc, s)) = happy_var_1+                                                      in OptionsPragma (l <^^> happy_var_3 <** (l:reverse happy_var_2 ++ [happy_var_3])) (readTool mc) s+	)}}}++happyReduce_21 = happySpecReduce_3  6# happyReduction_21+happyReduction_21 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 ANN) -> +	case happyOut76 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 PragmaEnd) -> +	happyIn17+		 (AnnModulePragma (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3]) happy_var_2+	)}}}++happyReduce_22 = happySpecReduce_3  7# happyReduction_22+happyReduction_22 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut216 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> +	case happyOut18 happy_x_3 of { happy_var_3 -> +	happyIn18+		 ((happy_var_1 : fst happy_var_3, happy_var_2 : snd happy_var_3)+	)}}}++happyReduce_23 = happySpecReduce_1  7# happyReduction_23+happyReduction_23 happy_x_1+	 =  case happyOut216 happy_x_1 of { happy_var_1 -> +	happyIn18+		 (([happy_var_1],[])+	)}++happyReduce_24 = happySpecReduce_2  8# happyReduction_24+happyReduction_24 happy_x_2+	happy_x_1+	 =  case happyOut20 happy_x_1 of { happy_var_1 -> +	case happyOut22 happy_x_2 of { happy_var_2 -> +	happyIn19+		 (let (is,ds,ss1,inf) = happy_var_2+                 in \os ss l -> Module (l <++> inf <** (ss ++ ss1)) happy_var_1 os is ds+	)}}++happyReduce_25 = happyReduce 5# 9# happyReduction_25+happyReduction_25 (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 { (Loc happy_var_1 KW_Module) -> +	case happyOut227 happy_x_2 of { happy_var_2 -> +	case happyOut21 happy_x_3 of { happy_var_3 -> +	case happyOut26 happy_x_4 of { happy_var_4 -> +	case happyOutTok happy_x_5 of { (Loc happy_var_5 KW_Where) -> +	happyIn20+		 (Just $ ModuleHead (happy_var_1 <^^> happy_var_5 <** [happy_var_1,happy_var_5]) happy_var_2 happy_var_3 happy_var_4+	) `HappyStk` happyRest}}}}}++happyReduce_26 = happySpecReduce_0  9# happyReduction_26+happyReduction_26  =  happyIn20+		 (Nothing+	)++happyReduce_27 = happySpecReduce_3  10# happyReduction_27+happyReduction_27 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 DEPRECATED) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 PragmaEnd) -> +	happyIn21+		 (let Loc l (StringTok (s,_)) = happy_var_2 in Just $ DeprText (happy_var_1 <^^> happy_var_3 <** [happy_var_1,l,happy_var_3]) s+	)}}}++happyReduce_28 = happySpecReduce_3  10# happyReduction_28+happyReduction_28 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 WARNING) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 PragmaEnd) -> +	happyIn21+		 (let Loc l (StringTok (s,_)) = happy_var_2 in Just $ WarnText (happy_var_1 <^^> happy_var_3 <** [happy_var_1,l,happy_var_3]) s+	)}}}++happyReduce_29 = happySpecReduce_0  10# happyReduction_29+happyReduction_29  =  happyIn21+		 (Nothing+	)++happyReduce_30 = happySpecReduce_3  11# happyReduction_30+happyReduction_30 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftCurly) -> +	case happyOut23 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightCurly) -> +	happyIn22+		 (let (is,ds,ss) = happy_var_2 in (is,ds,happy_var_1:ss ++ [happy_var_3], happy_var_1 <^^> happy_var_3)+	)}}}++happyReduce_31 = happySpecReduce_3  11# happyReduction_31+happyReduction_31 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut225 happy_x_1 of { happy_var_1 -> +	case happyOut23 happy_x_2 of { happy_var_2 -> +	case happyOut226 happy_x_3 of { happy_var_3 -> +	happyIn22+		 (let (is,ds,ss) = happy_var_2 in (is,ds,happy_var_1:ss ++ [happy_var_3], happy_var_1 <^^> happy_var_3)+	)}}}++happyReduce_32 = happyReduce 4# 12# happyReduction_32+happyReduction_32 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut25 happy_x_1 of { happy_var_1 -> +	case happyOut31 happy_x_2 of { happy_var_2 -> +	case happyOut24 happy_x_3 of { happy_var_3 -> +	case happyOut48 happy_x_4 of { happy_var_4 -> +	happyIn23+		 ((reverse (fst happy_var_2), fst happy_var_4, reverse happy_var_1 ++ snd happy_var_2 ++ reverse happy_var_3 ++ snd happy_var_4)+	) `HappyStk` happyRest}}}}++happyReduce_33 = happySpecReduce_2  12# happyReduction_33+happyReduction_33 happy_x_2+	happy_x_1+	 =  case happyOut25 happy_x_1 of { happy_var_1 -> +	case happyOut48 happy_x_2 of { happy_var_2 -> +	happyIn23+		 (([], fst happy_var_2, reverse happy_var_1 ++ snd happy_var_2)+	)}}++happyReduce_34 = happySpecReduce_3  12# happyReduction_34+happyReduction_34 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut25 happy_x_1 of { happy_var_1 -> +	case happyOut31 happy_x_2 of { happy_var_2 -> +	case happyOut25 happy_x_3 of { happy_var_3 -> +	happyIn23+		 ((reverse (fst happy_var_2), [], reverse happy_var_1 ++ snd happy_var_2 ++ reverse happy_var_3)+	)}}}++happyReduce_35 = happySpecReduce_1  12# happyReduction_35+happyReduction_35 happy_x_1+	 =  case happyOut25 happy_x_1 of { happy_var_1 -> +	happyIn23+		 (([], [], reverse happy_var_1)+	)}++happyReduce_36 = happySpecReduce_2  13# happyReduction_36+happyReduction_36 happy_x_2+	happy_x_1+	 =  case happyOut25 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 SemiColon) -> +	happyIn24+		 (happy_var_2 : happy_var_1+	)}}++happyReduce_37 = happySpecReduce_1  14# happyReduction_37+happyReduction_37 happy_x_1+	 =  case happyOut24 happy_x_1 of { happy_var_1 -> +	happyIn25+		 (happy_var_1+	)}++happyReduce_38 = happySpecReduce_0  14# happyReduction_38+happyReduction_38  =  happyIn25+		 ([]+	)++happyReduce_39 = happySpecReduce_1  15# happyReduction_39+happyReduction_39 happy_x_1+	 =  case happyOut27 happy_x_1 of { happy_var_1 -> +	happyIn26+		 (Just happy_var_1+	)}++happyReduce_40 = happySpecReduce_0  15# happyReduction_40+happyReduction_40  =  happyIn26+		 (Nothing+	)++happyReduce_41 = happyReduce 4# 16# happyReduction_41+happyReduction_41 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> +	case happyOut29 happy_x_2 of { happy_var_2 -> +	case happyOut28 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (Loc happy_var_4 RightParen) -> +	happyIn27+		 (ExportSpecList (happy_var_1 <^^> happy_var_4 <** (happy_var_1:reverse (snd happy_var_2) ++ happy_var_3 ++ [happy_var_4])) (reverse (fst happy_var_2))+	) `HappyStk` happyRest}}}}++happyReduce_42 = happySpecReduce_3  16# happyReduction_42+happyReduction_42 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> +	case happyOut28 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> +	happyIn27+		 (ExportSpecList (happy_var_1 <^^> happy_var_3 <** (happy_var_1:happy_var_2++[happy_var_3])) []+	)}}}++happyReduce_43 = happySpecReduce_1  17# happyReduction_43+happyReduction_43 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Comma) -> +	happyIn28+		 ([happy_var_1]+	)}++happyReduce_44 = happySpecReduce_0  17# happyReduction_44+happyReduction_44  =  happyIn28+		 ([  ]+	)++happyReduce_45 = happySpecReduce_3  18# happyReduction_45+happyReduction_45 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut29 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> +	case happyOut30 happy_x_3 of { happy_var_3 -> +	happyIn29+		 ((happy_var_3 : fst happy_var_1, happy_var_2 : snd happy_var_1)+	)}}}++happyReduce_46 = happySpecReduce_1  18# happyReduction_46+happyReduction_46 happy_x_1+	 =  case happyOut30 happy_x_1 of { happy_var_1 -> +	happyIn29+		 (([happy_var_1],[])+	)}++happyReduce_47 = happySpecReduce_1  19# happyReduction_47+happyReduction_47 happy_x_1+	 =  case happyOut198 happy_x_1 of { happy_var_1 -> +	happyIn30+		 (EVar (ann happy_var_1) happy_var_1+	)}++happyReduce_48 = happySpecReduce_1  19# happyReduction_48+happyReduction_48 happy_x_1+	 =  case happyOut229 happy_x_1 of { happy_var_1 -> +	happyIn30+		 (EAbs (ann happy_var_1) happy_var_1+	)}++happyReduce_49 = happyReduce 4# 19# happyReduction_49+happyReduction_49 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut229 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftParen) -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 DotDot) -> +	case happyOutTok happy_x_4 of { (Loc happy_var_4 RightParen) -> +	happyIn30+		 (EThingAll  (ann happy_var_1 <++> nIS happy_var_4 <** [happy_var_2,happy_var_3,happy_var_4]) happy_var_1+	) `HappyStk` happyRest}}}}++happyReduce_50 = happySpecReduce_3  19# happyReduction_50+happyReduction_50 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut229 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftParen) -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> +	happyIn30+		 (EThingWith (ann happy_var_1 <++> nIS happy_var_3 <** [happy_var_2,happy_var_3])    happy_var_1 []+	)}}}++happyReduce_51 = happyReduce 4# 19# happyReduction_51+happyReduction_51 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut229 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftParen) -> +	case happyOut42 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (Loc happy_var_4 RightParen) -> +	happyIn30+		 (EThingWith (ann happy_var_1 <++> nIS happy_var_4 <** (happy_var_2:reverse (snd happy_var_3) ++ [happy_var_4])) happy_var_1 (reverse (fst happy_var_3))+	) `HappyStk` happyRest}}}}++happyReduce_52 = happySpecReduce_2  19# happyReduction_52+happyReduction_52 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Module) -> +	case happyOut227 happy_x_2 of { happy_var_2 -> +	happyIn30+		 (EModuleContents (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2+	)}}++happyReduce_53 = happySpecReduce_3  20# happyReduction_53+happyReduction_53 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut31 happy_x_1 of { happy_var_1 -> +	case happyOut24 happy_x_2 of { happy_var_2 -> +	case happyOut32 happy_x_3 of { happy_var_3 -> +	happyIn31+		 ((happy_var_3 : fst happy_var_1, snd happy_var_1 ++ reverse happy_var_2)+	)}}}++happyReduce_54 = happySpecReduce_1  20# happyReduction_54+happyReduction_54 happy_x_1+	 =  case happyOut32 happy_x_1 of { happy_var_1 -> +	happyIn31+		 (([happy_var_1],[])+	)}++happyReduce_55 = happyReduce 7# 21# happyReduction_55+happyReduction_55 (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 { (Loc happy_var_1 KW_Import) -> +	case happyOut33 happy_x_2 of { happy_var_2 -> +	case happyOut34 happy_x_3 of { happy_var_3 -> +	case happyOut35 happy_x_4 of { happy_var_4 -> +	case happyOut227 happy_x_5 of { happy_var_5 -> +	case happyOut36 happy_x_6 of { happy_var_6 -> +	case happyOut37 happy_x_7 of { happy_var_7 -> +	happyIn32+		 (let { (mmn,ss,ml) = happy_var_6 ;+                                      l = nIS happy_var_1 <++> ann happy_var_5 <+?> ml <+?> (fmap ann) happy_var_7 <** (happy_var_1:snd happy_var_2 ++ snd happy_var_3 ++ snd happy_var_4 ++ ss)}+                                 in ImportDecl l happy_var_5 (fst happy_var_3) (fst happy_var_2) (fst happy_var_4) mmn happy_var_7+	) `HappyStk` happyRest}}}}}}}++happyReduce_56 = happySpecReduce_2  22# happyReduction_56+happyReduction_56 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 SOURCE) -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 PragmaEnd) -> +	happyIn33+		 ((True,[happy_var_1,happy_var_2])+	)}}++happyReduce_57 = happySpecReduce_0  22# happyReduction_57+happyReduction_57  =  happyIn33+		 ((False,[])+	)++happyReduce_58 = happySpecReduce_1  23# happyReduction_58+happyReduction_58 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Qualified) -> +	happyIn34+		 ((True,[happy_var_1])+	)}++happyReduce_59 = happySpecReduce_0  23# happyReduction_59+happyReduction_59  =  happyIn34+		 ((False, [])+	)++happyReduce_60 = happyMonadReduce 1# 24# happyReduction_60+happyReduction_60 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> +	( do { checkEnabled PackageImports ;+                                                      let { Loc l (StringTok (s,_)) = happy_var_1 } ;+                                                      return $ (Just s,[l]) })}+	) (\r -> happyReturn (happyIn35 r))++happyReduce_61 = happySpecReduce_0  24# happyReduction_61+happyReduction_61  =  happyIn35+		 ((Nothing,[])+	)++happyReduce_62 = happySpecReduce_2  25# happyReduction_62+happyReduction_62 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_As) -> +	case happyOut227 happy_x_2 of { happy_var_2 -> +	happyIn36+		 ((Just happy_var_2,[happy_var_1],Just (nIS happy_var_1 <++> ann happy_var_2))+	)}}++happyReduce_63 = happySpecReduce_0  25# happyReduction_63+happyReduction_63  =  happyIn36+		 ((Nothing,[],Nothing)+	)++happyReduce_64 = happySpecReduce_1  26# happyReduction_64+happyReduction_64 happy_x_1+	 =  case happyOut38 happy_x_1 of { happy_var_1 -> +	happyIn37+		 (Just happy_var_1+	)}++happyReduce_65 = happySpecReduce_0  26# happyReduction_65+happyReduction_65  =  happyIn37+		 (Nothing+	)++happyReduce_66 = happyReduce 5# 27# happyReduction_66+happyReduction_66 (happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut39 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftParen) -> +	case happyOut40 happy_x_3 of { happy_var_3 -> +	case happyOut28 happy_x_4 of { happy_var_4 -> +	case happyOutTok happy_x_5 of { (Loc happy_var_5 RightParen) -> +	happyIn38+		 (let {(b,ml,s) = happy_var_1 ;+                                                      l = (ml <?+> (happy_var_2 <^^> happy_var_5)) <** (s ++ happy_var_2:reverse (snd happy_var_3) ++ happy_var_4 ++ [happy_var_5])}+                                                 in ImportSpecList l b (reverse (fst happy_var_3))+	) `HappyStk` happyRest}}}}}++happyReduce_67 = happyReduce 4# 27# happyReduction_67+happyReduction_67 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut39 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftParen) -> +	case happyOut28 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (Loc happy_var_4 RightParen) -> +	happyIn38+		 (let {(b,ml,s) = happy_var_1 ; l = (ml <?+> (happy_var_2 <^^> happy_var_4)) <** (s ++ happy_var_2:happy_var_3 ++ [happy_var_4])}+                                                 in ImportSpecList l b []+	) `HappyStk` happyRest}}}}++happyReduce_68 = happySpecReduce_1  28# happyReduction_68+happyReduction_68 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Hiding) -> +	happyIn39+		 ((True,Just (nIS happy_var_1),[happy_var_1])+	)}++happyReduce_69 = happySpecReduce_0  28# happyReduction_69+happyReduction_69  =  happyIn39+		 ((False,Nothing,[])+	)++happyReduce_70 = happySpecReduce_3  29# happyReduction_70+happyReduction_70 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut40 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> +	case happyOut41 happy_x_3 of { happy_var_3 -> +	happyIn40+		 ((happy_var_3 : fst happy_var_1, happy_var_2 : snd happy_var_1)+	)}}}++happyReduce_71 = happySpecReduce_1  29# happyReduction_71+happyReduction_71 happy_x_1+	 =  case happyOut41 happy_x_1 of { happy_var_1 -> +	happyIn40+		 (([happy_var_1],[])+	)}++happyReduce_72 = happySpecReduce_1  30# happyReduction_72+happyReduction_72 happy_x_1+	 =  case happyOut196 happy_x_1 of { happy_var_1 -> +	happyIn41+		 (IVar (ann happy_var_1) happy_var_1+	)}++happyReduce_73 = happySpecReduce_1  30# happyReduction_73+happyReduction_73 happy_x_1+	 =  case happyOut228 happy_x_1 of { happy_var_1 -> +	happyIn41+		 (IAbs (ann happy_var_1) happy_var_1+	)}++happyReduce_74 = happyReduce 4# 30# happyReduction_74+happyReduction_74 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut228 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftParen) -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 DotDot) -> +	case happyOutTok happy_x_4 of { (Loc happy_var_4 RightParen) -> +	happyIn41+		 (IThingAll  (ann happy_var_1 <++> nIS happy_var_4 <** [happy_var_2,happy_var_3,happy_var_4]) happy_var_1+	) `HappyStk` happyRest}}}}++happyReduce_75 = happySpecReduce_3  30# happyReduction_75+happyReduction_75 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut228 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftParen) -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> +	happyIn41+		 (IThingWith (ann happy_var_1 <++> nIS happy_var_3 <** [happy_var_2,happy_var_3])    happy_var_1 []+	)}}}++happyReduce_76 = happyReduce 4# 30# happyReduction_76+happyReduction_76 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut228 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftParen) -> +	case happyOut42 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (Loc happy_var_4 RightParen) -> +	happyIn41+		 (IThingWith (ann happy_var_1 <++> nIS happy_var_4 <** (happy_var_2:reverse (snd happy_var_3) ++ [happy_var_4])) happy_var_1 (reverse (fst happy_var_3))+	) `HappyStk` happyRest}}}}++happyReduce_77 = happySpecReduce_3  31# happyReduction_77+happyReduction_77 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut42 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> +	case happyOut43 happy_x_3 of { happy_var_3 -> +	happyIn42+		 ((happy_var_3 : fst happy_var_1, happy_var_2 : snd happy_var_1)+	)}}}++happyReduce_78 = happySpecReduce_1  31# happyReduction_78+happyReduction_78 happy_x_1+	 =  case happyOut43 happy_x_1 of { happy_var_1 -> +	happyIn42+		 (([happy_var_1],[])+	)}++happyReduce_79 = happySpecReduce_1  32# happyReduction_79+happyReduction_79 happy_x_1+	 =  case happyOut196 happy_x_1 of { happy_var_1 -> +	happyIn43+		 (VarName (ann happy_var_1) happy_var_1+	)}++happyReduce_80 = happySpecReduce_1  32# happyReduction_80+happyReduction_80 happy_x_1+	 =  case happyOut200 happy_x_1 of { happy_var_1 -> +	happyIn43+		 (ConName (ann happy_var_1) happy_var_1+	)}++happyReduce_81 = happySpecReduce_3  33# happyReduction_81+happyReduction_81 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut46 happy_x_1 of { happy_var_1 -> +	case happyOut45 happy_x_2 of { happy_var_2 -> +	case happyOut47 happy_x_3 of { happy_var_3 -> +	happyIn44+		 (let (ops,ss,l) = happy_var_3+                                                 in InfixDecl (ann happy_var_1 <++> l <** (snd happy_var_2 ++ reverse ss)) happy_var_1 (fst happy_var_2) (reverse ops)+	)}}}++happyReduce_82 = happySpecReduce_0  34# happyReduction_82+happyReduction_82  =  happyIn45+		 ((Nothing, [])+	)++happyReduce_83 = happyMonadReduce 1# 34# happyReduction_83+happyReduction_83 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOutTok happy_x_1 of { happy_var_1 -> +	( let Loc l (IntTok (i,_)) = happy_var_1 in checkPrec i >>= \i -> return (Just i, [l]))}+	) (\r -> happyReturn (happyIn45 r))++happyReduce_84 = happySpecReduce_1  35# happyReduction_84+happyReduction_84 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Infix) -> +	happyIn46+		 (AssocNone  $ nIS happy_var_1+	)}++happyReduce_85 = happySpecReduce_1  35# happyReduction_85+happyReduction_85 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_InfixL) -> +	happyIn46+		 (AssocLeft  $ nIS happy_var_1+	)}++happyReduce_86 = happySpecReduce_1  35# happyReduction_86+happyReduction_86 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_InfixR) -> +	happyIn46+		 (AssocRight $ nIS happy_var_1+	)}++happyReduce_87 = happySpecReduce_3  36# happyReduction_87+happyReduction_87 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut47 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> +	case happyOut207 happy_x_3 of { happy_var_3 -> +	happyIn47+		 (let (ops,ss,l) = happy_var_1 in (happy_var_3 : ops, happy_var_2 : ss, l <++> ann happy_var_3)+	)}}}++happyReduce_88 = happySpecReduce_1  36# happyReduction_88+happyReduction_88 happy_x_1+	 =  case happyOut207 happy_x_1 of { happy_var_1 -> +	happyIn47+		 (([happy_var_1],[],ann happy_var_1)+	)}++happyReduce_89 = happyMonadReduce 2# 37# happyReduction_89+happyReduction_89 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut49 happy_x_1 of { happy_var_1 -> +	case happyOut25 happy_x_2 of { happy_var_2 -> +	( checkRevDecls (fst happy_var_1) >>= \ds -> return (ds, snd happy_var_1 ++ reverse happy_var_2))}}+	) (\r -> happyReturn (happyIn48 r))++happyReduce_90 = happySpecReduce_3  38# happyReduction_90+happyReduction_90 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut49 happy_x_1 of { happy_var_1 -> +	case happyOut24 happy_x_2 of { happy_var_2 -> +	case happyOut50 happy_x_3 of { happy_var_3 -> +	happyIn49+		 ((happy_var_3 : fst happy_var_1, snd happy_var_1 ++ reverse happy_var_2)+	)}}}++happyReduce_91 = happySpecReduce_1  38# happyReduction_91+happyReduction_91 happy_x_1+	 =  case happyOut50 happy_x_1 of { happy_var_1 -> +	happyIn49+		 (([happy_var_1],[])+	)}++happyReduce_92 = happyMonadReduce 4# 39# happyReduction_92+happyReduction_92 (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 { (Loc happy_var_1 KW_Type) -> +	case happyOut78 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 Equals) -> +	case happyOut88 happy_x_4 of { happy_var_4 -> +	( do { dh <- checkSimpleType happy_var_2;+                       let {l = nIS happy_var_1 <++> ann happy_var_4 <** [happy_var_1,happy_var_3]};+                       return (TypeDecl l dh happy_var_4) })}}}}+	) (\r -> happyReturn (happyIn50 r))++happyReduce_93 = happyMonadReduce 4# 39# happyReduction_93+happyReduction_93 (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 { (Loc happy_var_1 KW_Type) -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 KW_Family) -> +	case happyOut80 happy_x_3 of { happy_var_3 -> +	case happyOut122 happy_x_4 of { happy_var_4 -> +	( do { dh <- checkSimpleType happy_var_3;+                       let {l = nIS happy_var_1 <++> ann happy_var_3 <+?> (fmap ann) (fst happy_var_4) <** (happy_var_1:happy_var_2:snd happy_var_4)};+                       return (TypeFamDecl l dh (fst happy_var_4)) })}}}}+	) (\r -> happyReturn (happyIn50 r))++happyReduce_94 = happyMonadReduce 5# 39# happyReduction_94+happyReduction_94 (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 { (Loc happy_var_1 KW_Type) -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 KW_Instance) -> +	case happyOut77 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (Loc happy_var_4 Equals) -> +	case happyOut88 happy_x_5 of { happy_var_5 -> +	( do { -- no checkSimpleType happy_var_4 since dtype may contain type patterns+                       checkEnabled TypeFamilies ;+                       let {l = nIS happy_var_1 <++> ann happy_var_5 <** [happy_var_1,happy_var_2,happy_var_4]};+                       return (TypeInsDecl l happy_var_3 happy_var_5) })}}}}}+	) (\r -> happyReturn (happyIn50 r))++happyReduce_95 = happyMonadReduce 4# 39# happyReduction_95+happyReduction_95 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut51 happy_x_1 of { happy_var_1 -> +	case happyOut89 happy_x_2 of { happy_var_2 -> +	case happyOut104 happy_x_3 of { happy_var_3 -> +	case happyOut116 happy_x_4 of { happy_var_4 -> +	( do { (cs,dh) <- checkDataHeader happy_var_2;+                       let { (qds,ss,minf) = happy_var_3;+                             l = happy_var_1 <> happy_var_2 <+?> minf <+?> fmap ann happy_var_4 <** ss};+                       checkDataOrNew happy_var_1 qds;+                       return (DataDecl l happy_var_1 cs dh (reverse qds) happy_var_4) })}}}}+	) (\r -> happyReturn (happyIn50 r))++happyReduce_96 = happyMonadReduce 5# 39# 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) tk+	 = happyThen (case happyOut51 happy_x_1 of { happy_var_1 -> +	case happyOut89 happy_x_2 of { happy_var_2 -> +	case happyOut122 happy_x_3 of { happy_var_3 -> +	case happyOut100 happy_x_4 of { happy_var_4 -> +	case happyOut116 happy_x_5 of { happy_var_5 -> +	( do { (cs,dh) <- checkDataHeader happy_var_2;+                       let { (gs,ss,minf) = happy_var_4;+                             l = ann happy_var_1 <+?> minf <+?> fmap ann happy_var_5 <** (snd happy_var_3 ++ ss)};+                       checkDataOrNewG happy_var_1 gs;+                       case (gs, fst happy_var_3) of+                        ([], Nothing) -> return (DataDecl l happy_var_1 cs dh [] happy_var_5)+                        _ -> checkEnabled GADTs >> return (GDataDecl l happy_var_1 cs dh (fst happy_var_3) (reverse gs) happy_var_5) })}}}}}+	) (\r -> happyReturn (happyIn50 r))++happyReduce_97 = happyMonadReduce 4# 39# happyReduction_97+happyReduction_97 (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 { (Loc happy_var_1 KW_Data) -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 KW_Family) -> +	case happyOut89 happy_x_3 of { happy_var_3 -> +	case happyOut122 happy_x_4 of { happy_var_4 -> +	( do { (cs,dh) <- checkDataHeader happy_var_3;+                       let {l = nIS happy_var_1 <++> ann happy_var_3 <+?> (fmap ann) (fst happy_var_4) <** (happy_var_1:happy_var_2:snd happy_var_4)};+                       return (DataFamDecl l cs dh (fst happy_var_4)) })}}}}+	) (\r -> happyReturn (happyIn50 r))++happyReduce_98 = happyMonadReduce 5# 39# happyReduction_98+happyReduction_98 (happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut51 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 KW_Instance) -> +	case happyOut88 happy_x_3 of { happy_var_3 -> +	case happyOut104 happy_x_4 of { happy_var_4 -> +	case happyOut116 happy_x_5 of { happy_var_5 -> +	( do { -- (cs,c,t) <- checkDataHeader happy_var_4;+                       checkEnabled TypeFamilies ;+                       let { (qds,ss,minf) = happy_var_4 ;+                             l = happy_var_1 <> happy_var_3 <+?> minf <+?> fmap ann happy_var_5 <** happy_var_2:ss };+                       checkDataOrNew happy_var_1 qds;+                       return (DataInsDecl l happy_var_1 happy_var_3 (reverse qds) happy_var_5) })}}}}}+	) (\r -> happyReturn (happyIn50 r))++happyReduce_99 = happyMonadReduce 6# 39# happyReduction_99+happyReduction_99 (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 happyOut51 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 KW_Instance) -> +	case happyOut88 happy_x_3 of { happy_var_3 -> +	case happyOut122 happy_x_4 of { happy_var_4 -> +	case happyOut100 happy_x_5 of { happy_var_5 -> +	case happyOut116 happy_x_6 of { happy_var_6 -> +	( do { -- (cs,c,t) <- checkDataHeader happy_var_4;+                       checkEnabled TypeFamilies ;+                       let {(gs,ss,minf) = happy_var_5;+                            l = ann happy_var_1 <+?> minf <+?> fmap ann happy_var_6 <** (happy_var_2:snd happy_var_4 ++ ss)};+                       checkDataOrNewG happy_var_1 gs;+                       return (GDataInsDecl l happy_var_1 happy_var_3 (fst happy_var_4) (reverse gs) happy_var_6) })}}}}}}+	) (\r -> happyReturn (happyIn50 r))++happyReduce_100 = happyMonadReduce 4# 39# happyReduction_100+happyReduction_100 (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 { (Loc happy_var_1 KW_Class) -> +	case happyOut89 happy_x_2 of { happy_var_2 -> +	case happyOut97 happy_x_3 of { happy_var_3 -> +	case happyOut123 happy_x_4 of { happy_var_4 -> +	( do { (cs,dh) <- checkClassHeader happy_var_2;+                       let {(fds,ss1,minf1) = happy_var_3;(mcs,ss2,minf2) = happy_var_4} ;+                       let { l = nIS happy_var_1 <++> ann happy_var_2 <+?> minf1 <+?> minf2 <** (happy_var_1:ss1 ++ ss2)} ;+                       return (ClassDecl l cs dh fds mcs) })}}}}+	) (\r -> happyReturn (happyIn50 r))++happyReduce_101 = happyMonadReduce 3# 39# happyReduction_101+happyReduction_101 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Instance) -> +	case happyOut89 happy_x_2 of { happy_var_2 -> +	case happyOut128 happy_x_3 of { happy_var_3 -> +	( do { (cs,ih) <- checkInstHeader happy_var_2;+                       let {(mis,ss,minf) = happy_var_3};+                       return (InstDecl (nIS happy_var_1 <++> ann happy_var_2 <+?> minf <** (happy_var_1:ss)) cs ih mis) })}}}+	) (\r -> happyReturn (happyIn50 r))++happyReduce_102 = happyMonadReduce 3# 39# happyReduction_102+happyReduction_102 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Deriving) -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 KW_Instance) -> +	case happyOut89 happy_x_3 of { happy_var_3 -> +	( do { checkEnabled StandaloneDeriving ;+                       (cs, ih) <- checkInstHeader happy_var_3;+                       let {l = nIS happy_var_1 <++> ann happy_var_3 <** [happy_var_1,happy_var_2]};+                       return (DerivDecl l cs ih) })}}}+	) (\r -> happyReturn (happyIn50 r))++happyReduce_103 = happyReduce 4# 39# happyReduction_103+happyReduction_103 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Default) -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftParen) -> +	case happyOut52 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (Loc happy_var_4 RightParen) -> +	happyIn50+		 (DefaultDecl (happy_var_1 <^^> happy_var_4 <** (happy_var_1:happy_var_2 : snd happy_var_3 ++ [happy_var_4])) (fst happy_var_3)+	) `HappyStk` happyRest}}}}++happyReduce_104 = happyMonadReduce 1# 39# happyReduction_104+happyReduction_104 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut141 happy_x_1 of { happy_var_1 -> +	( checkEnabled TemplateHaskell >> checkExpr happy_var_1 >>= \e -> return (SpliceDecl (ann e) e))}+	) (\r -> happyReturn (happyIn50 r))++happyReduce_105 = happyReduce 5# 39# 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 happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Foreign) -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 KW_Import) -> +	case happyOut63 happy_x_3 of { happy_var_3 -> +	case happyOut64 happy_x_4 of { happy_var_4 -> +	case happyOut65 happy_x_5 of { happy_var_5 -> +	happyIn50+		 (let (s,n,t,ss) = happy_var_5 in ForImp (nIS happy_var_1 <++> ann t <** (happy_var_1:happy_var_2:ss)) happy_var_3 happy_var_4 s n t+	) `HappyStk` happyRest}}}}}++happyReduce_106 = happyReduce 4# 39# happyReduction_106+happyReduction_106 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Foreign) -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 KW_Export) -> +	case happyOut63 happy_x_3 of { happy_var_3 -> +	case happyOut65 happy_x_4 of { happy_var_4 -> +	happyIn50+		 (let (s,n,t,ss) = happy_var_4 in ForExp (nIS happy_var_1 <++> ann t <** (happy_var_1:happy_var_2:ss)) happy_var_3    s n t+	) `HappyStk` happyRest}}}}++happyReduce_107 = happySpecReduce_3  39# happyReduction_107+happyReduction_107 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 RULES) -> +	case happyOut66 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 PragmaEnd) -> +	happyIn50+		 (RulePragmaDecl (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3]) $ reverse happy_var_2+	)}}}++happyReduce_108 = happySpecReduce_3  39# happyReduction_108+happyReduction_108 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 DEPRECATED) -> +	case happyOut72 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 PragmaEnd) -> +	happyIn50+		 (DeprPragmaDecl (happy_var_1 <^^> happy_var_3 <** (happy_var_1:snd happy_var_2++[happy_var_3])) $ reverse (fst happy_var_2)+	)}}}++happyReduce_109 = happySpecReduce_3  39# happyReduction_109+happyReduction_109 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 WARNING) -> +	case happyOut72 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 PragmaEnd) -> +	happyIn50+		 (WarnPragmaDecl (happy_var_1 <^^> happy_var_3 <** (happy_var_1:snd happy_var_2++[happy_var_3])) $ reverse (fst happy_var_2)+	)}}}++happyReduce_110 = happySpecReduce_3  39# happyReduction_110+happyReduction_110 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 ANN) -> +	case happyOut76 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 PragmaEnd) -> +	happyIn50+		 (AnnPragma      (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3]) happy_var_2+	)}}}++happyReduce_111 = happySpecReduce_1  39# happyReduction_111+happyReduction_111 happy_x_1+	 =  case happyOut55 happy_x_1 of { happy_var_1 -> +	happyIn50+		 (happy_var_1+	)}++happyReduce_112 = happySpecReduce_1  40# happyReduction_112+happyReduction_112 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Data) -> +	happyIn51+		 (DataType $ nIS happy_var_1+	)}++happyReduce_113 = happySpecReduce_1  40# happyReduction_113+happyReduction_113 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_NewType) -> +	happyIn51+		 (NewType  $ nIS happy_var_1+	)}++happyReduce_114 = happyMonadReduce 1# 41# happyReduction_114+happyReduction_114 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut91 happy_x_1 of { happy_var_1 -> +	( do { ts <- mapM checkType (fst happy_var_1);+                                              return $ (reverse ts, reverse (snd happy_var_1)) })}+	) (\r -> happyReturn (happyIn52 r))++happyReduce_115 = happySpecReduce_1  41# happyReduction_115+happyReduction_115 happy_x_1+	 =  case happyOut79 happy_x_1 of { happy_var_1 -> +	happyIn52+		 (([happy_var_1],[])+	)}++happyReduce_116 = happySpecReduce_0  41# happyReduction_116+happyReduction_116  =  happyIn52+		 (([],[])+	)++happyReduce_117 = happyMonadReduce 3# 42# happyReduction_117+happyReduction_117 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut25 happy_x_1 of { happy_var_1 -> +	case happyOut54 happy_x_2 of { happy_var_2 -> +	case happyOut25 happy_x_3 of { happy_var_3 -> +	( checkRevDecls (fst happy_var_2) >>= \ds -> return (ds, reverse happy_var_1 ++ snd happy_var_2 ++ reverse happy_var_3))}}}+	) (\r -> happyReturn (happyIn53 r))++happyReduce_118 = happySpecReduce_1  42# happyReduction_118+happyReduction_118 happy_x_1+	 =  case happyOut25 happy_x_1 of { happy_var_1 -> +	happyIn53+		 (([],reverse happy_var_1)+	)}++happyReduce_119 = happySpecReduce_3  43# happyReduction_119+happyReduction_119 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut54 happy_x_1 of { happy_var_1 -> +	case happyOut24 happy_x_2 of { happy_var_2 -> +	case happyOut55 happy_x_3 of { happy_var_3 -> +	happyIn54+		 ((happy_var_3 : fst happy_var_1, snd happy_var_1 ++ reverse happy_var_2)+	)}}}++happyReduce_120 = happySpecReduce_1  43# happyReduction_120+happyReduction_120 happy_x_1+	 =  case happyOut55 happy_x_1 of { happy_var_1 -> +	happyIn54+		 (([happy_var_1],[])+	)}++happyReduce_121 = happySpecReduce_1  44# happyReduction_121+happyReduction_121 happy_x_1+	 =  case happyOut57 happy_x_1 of { happy_var_1 -> +	happyIn55+		 (happy_var_1+	)}++happyReduce_122 = happySpecReduce_1  44# happyReduction_122+happyReduction_122 happy_x_1+	 =  case happyOut44 happy_x_1 of { happy_var_1 -> +	happyIn55+		 (happy_var_1+	)}++happyReduce_123 = happySpecReduce_1  44# happyReduction_123+happyReduction_123 happy_x_1+	 =  case happyOut133 happy_x_1 of { happy_var_1 -> +	happyIn55+		 (happy_var_1+	)}++happyReduce_124 = happySpecReduce_3  45# happyReduction_124+happyReduction_124 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftCurly) -> +	case happyOut53 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightCurly) -> +	happyIn56+		 (BDecls (happy_var_1 <^^> happy_var_3 <** (happy_var_1:snd happy_var_2++[happy_var_3])) (fst happy_var_2)+	)}}}++happyReduce_125 = happySpecReduce_3  45# happyReduction_125+happyReduction_125 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut225 happy_x_1 of { happy_var_1 -> +	case happyOut53 happy_x_2 of { happy_var_2 -> +	case happyOut226 happy_x_3 of { happy_var_3 -> +	happyIn56+		 (BDecls (happy_var_1 <^^> happy_var_3 <** (happy_var_1:snd happy_var_2++[happy_var_3])) (fst happy_var_2)+	)}}}++happyReduce_126 = happyMonadReduce 3# 46# happyReduction_126+happyReduction_126 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut143 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 DoubleColon) -> +	case happyOut88 happy_x_3 of { happy_var_3 -> +	( do { v <- checkSigVar happy_var_1;+                                                               return $ TypeSig (happy_var_1 <> happy_var_3 <** [happy_var_2]) [v] happy_var_3 })}}}+	) (\r -> happyReturn (happyIn57 r))++happyReduce_127 = happyMonadReduce 5# 46# happyReduction_127+happyReduction_127 (happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut143 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> +	case happyOut62 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (Loc happy_var_4 DoubleColon) -> +	case happyOut88 happy_x_5 of { happy_var_5 -> +	( do { v <- checkSigVar happy_var_1;+                                                               let {(vs,ss,_) = happy_var_3 ; l = happy_var_1 <> happy_var_5 <** (happy_var_2 : reverse ss ++ [happy_var_4]) } ;+                                                               return $ TypeSig l (v : reverse vs) happy_var_5 })}}}}}+	) (\r -> happyReturn (happyIn57 r))++happyReduce_128 = happySpecReduce_1  46# happyReduction_128+happyReduction_128 happy_x_1+	 =  case happyOut58 happy_x_1 of { happy_var_1 -> +	happyIn57+		 (happy_var_1+	)}++happyReduce_129 = happyReduce 4# 47# happyReduction_129+happyReduction_129 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut68 happy_x_2 of { happy_var_2 -> +	case happyOut198 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (Loc happy_var_4 PragmaEnd) -> +	happyIn58+		 (let Loc l (INLINE s) = happy_var_1 in InlineSig (l <^^> happy_var_4 <** [l,happy_var_4]) s happy_var_2 happy_var_3+	) `HappyStk` happyRest}}}}++happyReduce_130 = happyReduce 4# 47# happyReduction_130+happyReduction_130 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 INLINE_CONLIKE) -> +	case happyOut68 happy_x_2 of { happy_var_2 -> +	case happyOut198 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (Loc happy_var_4 PragmaEnd) -> +	happyIn58+		 (InlineConlikeSig (happy_var_1 <^^> happy_var_4 <** [happy_var_1,happy_var_4]) happy_var_2 happy_var_3+	) `HappyStk` happyRest}}}}++happyReduce_131 = happyReduce 6# 47# happyReduction_131+happyReduction_131 (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 { (Loc happy_var_1 SPECIALISE) -> +	case happyOut68 happy_x_2 of { happy_var_2 -> +	case happyOut198 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (Loc happy_var_4 DoubleColon) -> +	case happyOut59 happy_x_5 of { happy_var_5 -> +	case happyOutTok happy_x_6 of { (Loc happy_var_6 PragmaEnd) -> +	happyIn58+		 (SpecSig (happy_var_1 <^^> happy_var_6 <** (happy_var_1: happy_var_4 : snd happy_var_5 ++ [happy_var_6])) happy_var_2 happy_var_3 (fst happy_var_5)+	) `HappyStk` happyRest}}}}}}++happyReduce_132 = happyReduce 6# 47# happyReduction_132+happyReduction_132 (happy_x_6 `HappyStk`+	happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut68 happy_x_2 of { happy_var_2 -> +	case happyOut198 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (Loc happy_var_4 DoubleColon) -> +	case happyOut59 happy_x_5 of { happy_var_5 -> +	case happyOutTok happy_x_6 of { (Loc happy_var_6 PragmaEnd) -> +	happyIn58+		 (let Loc l (SPECIALISE_INLINE s) = happy_var_1+               in SpecInlineSig (l <^^> happy_var_6 <** (l:happy_var_4:snd happy_var_5++[happy_var_6])) s happy_var_2 happy_var_3 (fst happy_var_5)+	) `HappyStk` happyRest}}}}}}++happyReduce_133 = happyMonadReduce 4# 47# happyReduction_133+happyReduction_133 (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 { (Loc happy_var_1 SPECIALISE) -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 KW_Instance) -> +	case happyOut89 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (Loc happy_var_4 PragmaEnd) -> +	( do { (cs,ih) <- checkInstHeader happy_var_3;+                                                               let {l = happy_var_1 <^^> happy_var_4 <** [happy_var_1,happy_var_2,happy_var_4]};+                                                               return $ InstSig l cs ih })}}}}+	) (\r -> happyReturn (happyIn58 r))++happyReduce_134 = happySpecReduce_1  48# happyReduction_134+happyReduction_134 happy_x_1+	 =  case happyOut60 happy_x_1 of { happy_var_1 -> +	happyIn59+		 (([happy_var_1],[])+	)}++happyReduce_135 = happySpecReduce_3  48# happyReduction_135+happyReduction_135 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut60 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> +	case happyOut59 happy_x_3 of { happy_var_3 -> +	happyIn59+		 ((happy_var_1 : fst happy_var_3, happy_var_2 : snd happy_var_3)+	)}}}++happyReduce_136 = happyMonadReduce 1# 49# happyReduction_136+happyReduction_136 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut89 happy_x_1 of { happy_var_1 -> +	( checkType $ mkTyForall (ann happy_var_1) Nothing Nothing happy_var_1)}+	) (\r -> happyReturn (happyIn60 r))++happyReduce_137 = happySpecReduce_1  50# happyReduction_137+happyReduction_137 happy_x_1+	 =  case happyOut56 happy_x_1 of { happy_var_1 -> +	happyIn61+		 (happy_var_1+	)}++happyReduce_138 = happySpecReduce_3  50# happyReduction_138+happyReduction_138 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftCurly) -> +	case happyOut192 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightCurly) -> +	happyIn61+		 (IPBinds (happy_var_1 <^^> happy_var_3 <** snd happy_var_2) (fst happy_var_2)+	)}}}++happyReduce_139 = happySpecReduce_3  50# happyReduction_139+happyReduction_139 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut225 happy_x_1 of { happy_var_1 -> +	case happyOut192 happy_x_2 of { happy_var_2 -> +	case happyOut226 happy_x_3 of { happy_var_3 -> +	happyIn61+		 (IPBinds (happy_var_1 <^^> happy_var_3 <** snd happy_var_2) (fst happy_var_2)+	)}}}++happyReduce_140 = happySpecReduce_3  51# happyReduction_140+happyReduction_140 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut62 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> +	case happyOut196 happy_x_3 of { happy_var_3 -> +	happyIn62+		 (let (ns,ss,l) = happy_var_1 in (happy_var_3 : ns, happy_var_2 : ss, l <++> ann happy_var_3)+	)}}}++happyReduce_141 = happyMonadReduce 1# 51# happyReduction_141+happyReduction_141 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut198 happy_x_1 of { happy_var_1 -> +	( do { n <- checkUnQual happy_var_1;+                                              return ([n],[],ann n) })}+	) (\r -> happyReturn (happyIn62 r))++happyReduce_142 = happySpecReduce_1  52# happyReduction_142+happyReduction_142 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_StdCall) -> +	happyIn63+		 (StdCall   (nIS happy_var_1)+	)}++happyReduce_143 = happySpecReduce_1  52# happyReduction_143+happyReduction_143 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_CCall) -> +	happyIn63+		 (CCall     (nIS happy_var_1)+	)}++happyReduce_144 = happySpecReduce_1  52# happyReduction_144+happyReduction_144 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_CPlusPlus) -> +	happyIn63+		 (CPlusPlus (nIS happy_var_1)+	)}++happyReduce_145 = happySpecReduce_1  52# happyReduction_145+happyReduction_145 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_DotNet) -> +	happyIn63+		 (DotNet    (nIS happy_var_1)+	)}++happyReduce_146 = happySpecReduce_1  52# happyReduction_146+happyReduction_146 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Jvm) -> +	happyIn63+		 (Jvm       (nIS happy_var_1)+	)}++happyReduce_147 = happySpecReduce_1  52# happyReduction_147+happyReduction_147 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Js) -> +	happyIn63+		 (Js        (nIS happy_var_1)+	)}++happyReduce_148 = happySpecReduce_1  52# happyReduction_148+happyReduction_148 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_CApi) -> +	happyIn63+		 (CApi      (nIS happy_var_1)+	)}++happyReduce_149 = happySpecReduce_1  53# happyReduction_149+happyReduction_149 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Safe) -> +	happyIn64+		 (Just $ PlaySafe  (nIS happy_var_1) False+	)}++happyReduce_150 = happySpecReduce_1  53# happyReduction_150+happyReduction_150 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Unsafe) -> +	happyIn64+		 (Just $ PlayRisky (nIS happy_var_1)+	)}++happyReduce_151 = happySpecReduce_1  53# happyReduction_151+happyReduction_151 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Threadsafe) -> +	happyIn64+		 (Just $ PlaySafe  (nIS happy_var_1) True+	)}++happyReduce_152 = happySpecReduce_1  53# happyReduction_152+happyReduction_152 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Interruptible) -> +	happyIn64+		 (Just $ PlayInterruptible (nIS happy_var_1)+	)}++happyReduce_153 = happySpecReduce_0  53# happyReduction_153+happyReduction_153  =  happyIn64+		 (Nothing+	)++happyReduce_154 = happyReduce 4# 54# happyReduction_154+happyReduction_154 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut197 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 DoubleColon) -> +	case happyOut77 happy_x_4 of { happy_var_4 -> +	happyIn65+		 (let Loc l (StringTok (s,_)) = happy_var_1 in (Just s, happy_var_2, happy_var_4, [l,happy_var_3])+	) `HappyStk` happyRest}}}}++happyReduce_155 = happySpecReduce_3  54# happyReduction_155+happyReduction_155 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut197 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 DoubleColon) -> +	case happyOut77 happy_x_3 of { happy_var_3 -> +	happyIn65+		 ((Nothing, happy_var_1, happy_var_3, [happy_var_2])+	)}}}++happyReduce_156 = happySpecReduce_3  55# happyReduction_156+happyReduction_156 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut66 happy_x_1 of { happy_var_1 -> +	case happyOut67 happy_x_3 of { happy_var_3 -> +	happyIn66+		 (happy_var_3 : happy_var_1+	)}}++happyReduce_157 = happySpecReduce_2  55# happyReduction_157+happyReduction_157 happy_x_2+	happy_x_1+	 =  case happyOut66 happy_x_1 of { happy_var_1 -> +	happyIn66+		 (happy_var_1+	)}++happyReduce_158 = happySpecReduce_1  55# happyReduction_158+happyReduction_158 happy_x_1+	 =  case happyOut67 happy_x_1 of { happy_var_1 -> +	happyIn66+		 ([happy_var_1]+	)}++happyReduce_159 = happySpecReduce_0  55# happyReduction_159+happyReduction_159  =  happyIn66+		 ([]+	)++happyReduce_160 = happyMonadReduce 6# 56# happyReduction_160+happyReduction_160 (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 { happy_var_1 -> +	case happyOut68 happy_x_2 of { happy_var_2 -> +	case happyOut69 happy_x_3 of { happy_var_3 -> +	case happyOut141 happy_x_4 of { happy_var_4 -> +	case happyOutTok happy_x_5 of { (Loc happy_var_5 Equals) -> +	case happyOut139 happy_x_6 of { happy_var_6 -> +	( do { let {Loc l (StringTok (s,_)) = happy_var_1};+                                                                  e <- checkRuleExpr happy_var_4;+                                                                  return $ Rule (nIS l <++> ann happy_var_6 <** l:snd happy_var_3 ++ [happy_var_5]) s happy_var_2 (fst happy_var_3) e happy_var_6 })}}}}}}+	) (\r -> happyReturn (happyIn67 r))++happyReduce_161 = happySpecReduce_0  57# happyReduction_161+happyReduction_161  =  happyIn68+		 (Nothing+	)++happyReduce_162 = happySpecReduce_3  57# happyReduction_162+happyReduction_162 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftSquare) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightSquare) -> +	happyIn68+		 (let Loc l (IntTok (i,_)) = happy_var_2 in Just $ ActiveFrom  (happy_var_1 <^^> happy_var_3 <** [happy_var_1,l,happy_var_3])    (fromInteger i)+	)}}}++happyReduce_163 = happyReduce 4# 57# happyReduction_163+happyReduction_163 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftSquare) -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 Tilde) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (Loc happy_var_4 RightSquare) -> +	happyIn68+		 (let Loc l (IntTok (i,_)) = happy_var_3 in Just $ ActiveUntil (happy_var_1 <^^> happy_var_4 <** [happy_var_1,happy_var_2,l,happy_var_4]) (fromInteger i)+	) `HappyStk` happyRest}}}}++happyReduce_164 = happySpecReduce_0  58# happyReduction_164+happyReduction_164  =  happyIn69+		 ((Nothing,[])+	)++happyReduce_165 = happySpecReduce_3  58# happyReduction_165+happyReduction_165 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Forall) -> +	case happyOut70 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 Dot) -> +	happyIn69+		 ((Just happy_var_2,[happy_var_1,happy_var_3])+	)}}}++happyReduce_166 = happySpecReduce_1  59# happyReduction_166+happyReduction_166 happy_x_1+	 =  case happyOut71 happy_x_1 of { happy_var_1 -> +	happyIn70+		 ([happy_var_1]+	)}++happyReduce_167 = happySpecReduce_2  59# happyReduction_167+happyReduction_167 happy_x_2+	happy_x_1+	 =  case happyOut71 happy_x_1 of { happy_var_1 -> +	case happyOut70 happy_x_2 of { happy_var_2 -> +	happyIn70+		 (happy_var_1 : happy_var_2+	)}}++happyReduce_168 = happySpecReduce_1  60# happyReduction_168+happyReduction_168 happy_x_1+	 =  case happyOut213 happy_x_1 of { happy_var_1 -> +	happyIn71+		 (RuleVar (ann happy_var_1) happy_var_1+	)}++happyReduce_169 = happyReduce 5# 60# happyReduction_169+happyReduction_169 (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 { (Loc happy_var_1 LeftParen) -> +	case happyOut213 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 DoubleColon) -> +	case happyOut88 happy_x_4 of { happy_var_4 -> +	case happyOutTok happy_x_5 of { (Loc happy_var_5 RightParen) -> +	happyIn71+		 (TypedRuleVar (happy_var_1 <^^> happy_var_5 <** [happy_var_1,happy_var_3,happy_var_5]) happy_var_2 happy_var_4+	) `HappyStk` happyRest}}}}}++happyReduce_170 = happySpecReduce_3  61# happyReduction_170+happyReduction_170 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut72 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 SemiColon) -> +	case happyOut73 happy_x_3 of { happy_var_3 -> +	happyIn72+		 ((fst happy_var_3 : fst happy_var_1, snd happy_var_1 ++ (happy_var_2:snd happy_var_3))+	)}}}++happyReduce_171 = happySpecReduce_2  61# happyReduction_171+happyReduction_171 happy_x_2+	happy_x_1+	 =  case happyOut72 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 SemiColon) -> +	happyIn72+		 ((fst happy_var_1, snd happy_var_1 ++ [happy_var_2])+	)}}++happyReduce_172 = happySpecReduce_1  61# happyReduction_172+happyReduction_172 happy_x_1+	 =  case happyOut73 happy_x_1 of { happy_var_1 -> +	happyIn72+		 (([fst happy_var_1],snd happy_var_1)+	)}++happyReduce_173 = happySpecReduce_0  61# happyReduction_173+happyReduction_173  =  happyIn72+		 (([],[])+	)++happyReduce_174 = happySpecReduce_2  62# happyReduction_174+happyReduction_174 happy_x_2+	happy_x_1+	 =  case happyOut74 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	happyIn73+		 (let Loc l (StringTok (s,_)) = happy_var_2 in ((fst happy_var_1,s),snd happy_var_1 ++ [l])+	)}}++happyReduce_175 = happySpecReduce_1  63# happyReduction_175+happyReduction_175 happy_x_1+	 =  case happyOut75 happy_x_1 of { happy_var_1 -> +	happyIn74+		 (([happy_var_1],[])+	)}++happyReduce_176 = happySpecReduce_3  63# happyReduction_176+happyReduction_176 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut75 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> +	case happyOut74 happy_x_3 of { happy_var_3 -> +	happyIn74+		 ((happy_var_1 : fst happy_var_3, happy_var_2 : snd happy_var_3)+	)}}}++happyReduce_177 = happySpecReduce_1  64# happyReduction_177+happyReduction_177 happy_x_1+	 =  case happyOut200 happy_x_1 of { happy_var_1 -> +	happyIn75+		 (happy_var_1+	)}++happyReduce_178 = happySpecReduce_1  64# happyReduction_178+happyReduction_178 happy_x_1+	 =  case happyOut196 happy_x_1 of { happy_var_1 -> +	happyIn75+		 (happy_var_1+	)}++happyReduce_179 = happyMonadReduce 3# 65# happyReduction_179+happyReduction_179 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Type) -> +	case happyOut216 happy_x_2 of { happy_var_2 -> +	case happyOut152 happy_x_3 of { happy_var_3 -> +	( checkExpr happy_var_3 >>= \e -> return (TypeAnn   (nIS happy_var_1 <++> ann e <** [happy_var_1]) happy_var_2 e))}}}+	) (\r -> happyReturn (happyIn76 r))++happyReduce_180 = happyMonadReduce 2# 65# happyReduction_180+happyReduction_180 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Module) -> +	case happyOut152 happy_x_2 of { happy_var_2 -> +	( checkExpr happy_var_2 >>= \e -> return (ModuleAnn (nIS happy_var_1 <++> ann e <** [happy_var_1])    e))}}+	) (\r -> happyReturn (happyIn76 r))++happyReduce_181 = happyMonadReduce 2# 65# happyReduction_181+happyReduction_181 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut75 happy_x_1 of { happy_var_1 -> +	case happyOut152 happy_x_2 of { happy_var_2 -> +	( checkExpr happy_var_2 >>= \e -> return (Ann (happy_var_1 <> e) happy_var_1 e))}}+	) (\r -> happyReturn (happyIn76 r))++happyReduce_182 = happyMonadReduce 1# 66# happyReduction_182+happyReduction_182 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut78 happy_x_1 of { happy_var_1 -> +	( checkType happy_var_1)}+	) (\r -> happyReturn (happyIn77 r))++happyReduce_183 = happySpecReduce_1  67# happyReduction_183+happyReduction_183 happy_x_1+	 =  case happyOut82 happy_x_1 of { happy_var_1 -> +	happyIn78+		 (happy_var_1+	)}++happyReduce_184 = happySpecReduce_3  67# happyReduction_184+happyReduction_184 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut82 happy_x_1 of { happy_var_1 -> +	case happyOut87 happy_x_2 of { happy_var_2 -> +	case happyOut78 happy_x_3 of { happy_var_3 -> +	happyIn78+		 (TyInfix (happy_var_1 <> happy_var_3) happy_var_1 happy_var_2 happy_var_3+	)}}}++happyReduce_185 = happySpecReduce_3  67# happyReduction_185+happyReduction_185 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut82 happy_x_1 of { happy_var_1 -> +	case happyOut232 happy_x_2 of { happy_var_2 -> +	case happyOut78 happy_x_3 of { happy_var_3 -> +	happyIn78+		 (TyInfix (happy_var_1 <> happy_var_3) happy_var_1 happy_var_2 happy_var_3+	)}}}++happyReduce_186 = happySpecReduce_3  67# happyReduction_186+happyReduction_186 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut82 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 RightArrow) -> +	case happyOut89 happy_x_3 of { happy_var_3 -> +	happyIn78+		 (TyFun (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3+	)}}}++happyReduce_187 = happyMonadReduce 3# 67# happyReduction_187+happyReduction_187 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut82 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 Tilde) -> +	case happyOut82 happy_x_3 of { happy_var_3 -> +	( do { checkEnabled TypeFamilies ;+                                              let {l = happy_var_1 <> happy_var_3 <** [happy_var_2]};+                                              return $ TyPred l $ EqualP l happy_var_1 happy_var_3 })}}}+	) (\r -> happyReturn (happyIn78 r))++happyReduce_188 = happyMonadReduce 1# 68# happyReduction_188+happyReduction_188 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut80 happy_x_1 of { happy_var_1 -> +	( checkType happy_var_1)}+	) (\r -> happyReturn (happyIn79 r))++happyReduce_189 = happySpecReduce_3  69# happyReduction_189+happyReduction_189 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut199 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 DoubleColon) -> +	case happyOut78 happy_x_3 of { happy_var_3 -> +	happyIn80+		 (let l = (happy_var_1 <> happy_var_3 <** [happy_var_2]) in TyPred l $ IParam l happy_var_1 happy_var_3+	)}}}++happyReduce_190 = happySpecReduce_1  69# happyReduction_190+happyReduction_190 happy_x_1+	 =  case happyOut78 happy_x_1 of { happy_var_1 -> +	happyIn80+		 (happy_var_1+	)}++happyReduce_191 = happyMonadReduce 1# 70# happyReduction_191+happyReduction_191 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut82 happy_x_1 of { happy_var_1 -> +	( checkType happy_var_1)}+	) (\r -> happyReturn (happyIn81 r))++happyReduce_192 = happySpecReduce_2  71# happyReduction_192+happyReduction_192 happy_x_2+	happy_x_1+	 =  case happyOut82 happy_x_1 of { happy_var_1 -> +	case happyOut84 happy_x_2 of { happy_var_2 -> +	happyIn82+		 (TyApp (happy_var_1 <> happy_var_2) happy_var_1 happy_var_2+	)}}++happyReduce_193 = happySpecReduce_1  71# happyReduction_193+happyReduction_193 happy_x_1+	 =  case happyOut84 happy_x_1 of { happy_var_1 -> +	happyIn82+		 (happy_var_1+	)}++happyReduce_194 = happyMonadReduce 1# 72# happyReduction_194+happyReduction_194 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut84 happy_x_1 of { happy_var_1 -> +	( checkType happy_var_1)}+	) (\r -> happyReturn (happyIn83 r))++happyReduce_195 = happySpecReduce_1  73# happyReduction_195+happyReduction_195 happy_x_1+	 =  case happyOut85 happy_x_1 of { happy_var_1 -> +	happyIn84+		 (TyCon   (ann happy_var_1) happy_var_1+	)}++happyReduce_196 = happySpecReduce_1  73# happyReduction_196+happyReduction_196 happy_x_1+	 =  case happyOut230 happy_x_1 of { happy_var_1 -> +	happyIn84+		 (TyVar   (ann happy_var_1) happy_var_1+	)}++happyReduce_197 = happySpecReduce_3  73# happyReduction_197+happyReduction_197 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> +	case happyOut91 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> +	happyIn84+		 (TyTuple (happy_var_1 <^^> happy_var_3 <** (happy_var_1:reverse (happy_var_3:snd happy_var_2))) Boxed   (reverse (fst happy_var_2))+	)}}}++happyReduce_198 = happySpecReduce_3  73# happyReduction_198+happyReduction_198 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftHashParen) -> +	case happyOut92 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightHashParen) -> +	happyIn84+		 (TyTuple (happy_var_1 <^^> happy_var_3 <** (happy_var_1:reverse (happy_var_3:snd happy_var_2))) Unboxed (reverse (fst happy_var_2))+	)}}}++happyReduce_199 = happySpecReduce_3  73# happyReduction_199+happyReduction_199 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftSquare) -> +	case happyOut80 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightSquare) -> +	happyIn84+		 (TyList  (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3]) happy_var_2+	)}}}++happyReduce_200 = happySpecReduce_3  73# happyReduction_200+happyReduction_200 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> +	case happyOut89 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> +	happyIn84+		 (TyParen (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3]) happy_var_2+	)}}}++happyReduce_201 = happyReduce 5# 73# happyReduction_201+happyReduction_201 (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 { (Loc happy_var_1 LeftParen) -> +	case happyOut89 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 DoubleColon) -> +	case happyOut119 happy_x_4 of { happy_var_4 -> +	case happyOutTok happy_x_5 of { (Loc happy_var_5 RightParen) -> +	happyIn84+		 (TyKind  (happy_var_1 <^^> happy_var_5 <** [happy_var_1,happy_var_3,happy_var_5]) happy_var_2 happy_var_4+	) `HappyStk` happyRest}}}}}++happyReduce_202 = happySpecReduce_1  74# happyReduction_202+happyReduction_202 happy_x_1+	 =  case happyOut86 happy_x_1 of { happy_var_1 -> +	happyIn85+		 (happy_var_1+	)}++happyReduce_203 = happySpecReduce_2  74# happyReduction_203+happyReduction_203 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 RightParen) -> +	happyIn85+		 (unit_tycon_name              (happy_var_1 <^^> happy_var_2 <** [happy_var_1,happy_var_2])+	)}}++happyReduce_204 = happySpecReduce_3  74# happyReduction_204+happyReduction_204 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 RightArrow) -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> +	happyIn85+		 (fun_tycon_name               (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_2,happy_var_3])+	)}}}++happyReduce_205 = happySpecReduce_2  74# happyReduction_205+happyReduction_205 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftSquare) -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 RightSquare) -> +	happyIn85+		 (list_tycon_name              (happy_var_1 <^^> happy_var_2 <** [happy_var_1,happy_var_2])+	)}}++happyReduce_206 = happySpecReduce_3  74# happyReduction_206+happyReduction_206 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> +	case happyOut155 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> +	happyIn85+		 (tuple_tycon_name             (happy_var_1 <^^> happy_var_3 <** (happy_var_1:reverse happy_var_2 ++ [happy_var_3])) Boxed (length happy_var_2)+	)}}}++happyReduce_207 = happySpecReduce_2  74# happyReduction_207+happyReduction_207 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftHashParen) -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 RightHashParen) -> +	happyIn85+		 (unboxed_singleton_tycon_name (happy_var_1 <^^> happy_var_2 <** [happy_var_1,happy_var_2])+	)}}++happyReduce_208 = happySpecReduce_3  74# happyReduction_208+happyReduction_208 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftHashParen) -> +	case happyOut155 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightHashParen) -> +	happyIn85+		 (tuple_tycon_name             (happy_var_1 <^^> happy_var_3 <** (happy_var_1:reverse happy_var_2 ++ [happy_var_3])) Unboxed (length happy_var_2)+	)}}}++happyReduce_209 = happySpecReduce_1  75# happyReduction_209+happyReduction_209 happy_x_1+	 =  case happyOut215 happy_x_1 of { happy_var_1 -> +	happyIn86+		 (happy_var_1+	)}++happyReduce_210 = happySpecReduce_3  75# happyReduction_210+happyReduction_210 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> +	case happyOut210 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> +	happyIn86+		 (fmap (const (happy_var_1 <^^> happy_var_3 <** [happy_var_1, srcInfoSpan (ann happy_var_2), happy_var_3])) happy_var_2+	)}}}++happyReduce_211 = happySpecReduce_3  75# happyReduction_211+happyReduction_211 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> +	case happyOut219 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> +	happyIn86+		 (fmap (const (happy_var_1 <^^> happy_var_3 <** [happy_var_1, srcInfoSpan (ann happy_var_2), happy_var_3])) happy_var_2+	)}}}++happyReduce_212 = happySpecReduce_1  76# happyReduction_212+happyReduction_212 happy_x_1+	 =  case happyOut206 happy_x_1 of { happy_var_1 -> +	happyIn87+		 (happy_var_1+	)}++happyReduce_213 = happyMonadReduce 1# 77# happyReduction_213+happyReduction_213 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut89 happy_x_1 of { happy_var_1 -> +	( checkType happy_var_1)}+	) (\r -> happyReturn (happyIn88 r))++happyReduce_214 = happyReduce 4# 78# happyReduction_214+happyReduction_214 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Forall) -> +	case happyOut93 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 Dot) -> +	case happyOut89 happy_x_4 of { happy_var_4 -> +	happyIn89+		 (TyForall (nIS happy_var_1 <++> ann happy_var_4 <** [happy_var_1,happy_var_3]) (Just (reverse (fst happy_var_2))) Nothing happy_var_4+	) `HappyStk` happyRest}}}}++happyReduce_215 = happySpecReduce_2  78# happyReduction_215+happyReduction_215 happy_x_2+	happy_x_1+	 =  case happyOut90 happy_x_1 of { happy_var_1 -> +	case happyOut89 happy_x_2 of { happy_var_2 -> +	happyIn89+		 (TyForall (happy_var_1 <> happy_var_2) Nothing (Just happy_var_1) happy_var_2+	)}}++happyReduce_216 = happySpecReduce_1  78# happyReduction_216+happyReduction_216 happy_x_1+	 =  case happyOut80 happy_x_1 of { happy_var_1 -> +	happyIn89+		 (happy_var_1+	)}++happyReduce_217 = happyMonadReduce 2# 79# happyReduction_217+happyReduction_217 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut82 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 DoubleArrow) -> +	( checkPContext $ (amap (\l -> l <++> nIS happy_var_2 <** (srcInfoPoints l ++ [happy_var_2]))) happy_var_1)}}+	) (\r -> happyReturn (happyIn90 r))++happyReduce_218 = happyMonadReduce 4# 79# happyReduction_218+happyReduction_218 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut82 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 Tilde) -> +	case happyOut82 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (Loc happy_var_4 DoubleArrow) -> +	( do { checkEnabled TypeFamilies;+                                              let {l = happy_var_1 <> happy_var_3 <** [happy_var_2,happy_var_4]};+                                              checkPContext (TyPred l $ EqualP l happy_var_1 happy_var_3) })}}}}+	) (\r -> happyReturn (happyIn90 r))++happyReduce_219 = happySpecReduce_3  80# happyReduction_219+happyReduction_219 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut92 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> +	case happyOut89 happy_x_3 of { happy_var_3 -> +	happyIn91+		 ((happy_var_3 : fst happy_var_1, happy_var_2 : snd happy_var_1)+	)}}}++happyReduce_220 = happySpecReduce_1  81# happyReduction_220+happyReduction_220 happy_x_1+	 =  case happyOut89 happy_x_1 of { happy_var_1 -> +	happyIn92+		 (([happy_var_1],[])+	)}++happyReduce_221 = happySpecReduce_3  81# happyReduction_221+happyReduction_221 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut92 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> +	case happyOut89 happy_x_3 of { happy_var_3 -> +	happyIn92+		 ((happy_var_3 : fst happy_var_1, happy_var_2 : snd happy_var_1)+	)}}}++happyReduce_222 = happySpecReduce_2  82# happyReduction_222+happyReduction_222 happy_x_2+	happy_x_1+	 =  case happyOut93 happy_x_1 of { happy_var_1 -> +	case happyOut94 happy_x_2 of { happy_var_2 -> +	happyIn93+		 ((happy_var_2 : fst happy_var_1, Just (snd happy_var_1 <?+> ann happy_var_2))+	)}}++happyReduce_223 = happySpecReduce_0  82# happyReduction_223+happyReduction_223  =  happyIn93+		 (([],Nothing)+	)++happyReduce_224 = happySpecReduce_1  83# happyReduction_224+happyReduction_224 happy_x_1+	 =  case happyOut230 happy_x_1 of { happy_var_1 -> +	happyIn94+		 (UnkindedVar (ann happy_var_1) happy_var_1+	)}++happyReduce_225 = happyReduce 5# 83# happyReduction_225+happyReduction_225 (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 { (Loc happy_var_1 LeftParen) -> +	case happyOut230 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 DoubleColon) -> +	case happyOut119 happy_x_4 of { happy_var_4 -> +	case happyOutTok happy_x_5 of { (Loc happy_var_5 RightParen) -> +	happyIn94+		 (KindedVar (happy_var_1 <^^> happy_var_5 <** [happy_var_1,happy_var_3,happy_var_5]) happy_var_2 happy_var_4+	) `HappyStk` happyRest}}}}}++happyReduce_226 = happySpecReduce_2  84# happyReduction_226+happyReduction_226 happy_x_2+	happy_x_1+	 =  case happyOut95 happy_x_1 of { happy_var_1 -> +	case happyOut230 happy_x_2 of { happy_var_2 -> +	happyIn95+		 ((happy_var_2 : fst happy_var_1, Just (snd happy_var_1 <?+> ann happy_var_2))+	)}}++happyReduce_227 = happySpecReduce_0  84# happyReduction_227+happyReduction_227  =  happyIn95+		 (([], Nothing)+	)++happyReduce_228 = happySpecReduce_2  85# happyReduction_228+happyReduction_228 happy_x_2+	happy_x_1+	 =  case happyOut95 happy_x_1 of { happy_var_1 -> +	case happyOut230 happy_x_2 of { happy_var_2 -> +	happyIn96+		 ((happy_var_2 : fst happy_var_1, snd happy_var_1 <?+> ann happy_var_2)+	)}}++happyReduce_229 = happySpecReduce_0  86# happyReduction_229+happyReduction_229  =  happyIn97+		 (([],[], Nothing)+	)++happyReduce_230 = happyMonadReduce 2# 86# happyReduction_230+happyReduction_230 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 Bar) -> +	case happyOut98 happy_x_2 of { happy_var_2 -> +	( do { checkEnabled FunctionalDependencies ;+                                              let {(fds,ss,l) = happy_var_2} ;+                                              return (reverse fds, happy_var_1 : reverse ss, Just (nIS happy_var_1 <++> l)) })}}+	) (\r -> happyReturn (happyIn97 r))++happyReduce_231 = happySpecReduce_3  87# happyReduction_231+happyReduction_231 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut98 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> +	case happyOut99 happy_x_3 of { happy_var_3 -> +	happyIn98+		 (let (fds,ss,l) = happy_var_1 in (happy_var_3 : fds, happy_var_2 : ss, l <++> ann happy_var_3)+	)}}}++happyReduce_232 = happySpecReduce_1  87# happyReduction_232+happyReduction_232 happy_x_1+	 =  case happyOut99 happy_x_1 of { happy_var_1 -> +	happyIn98+		 (([happy_var_1],[],ann happy_var_1)+	)}++happyReduce_233 = happySpecReduce_3  88# happyReduction_233+happyReduction_233 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut95 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 RightArrow) -> +	case happyOut96 happy_x_3 of { happy_var_3 -> +	happyIn99+		 (FunDep (snd happy_var_1 <?+> nIS happy_var_2 <++> snd happy_var_3 <** [happy_var_2]) (reverse (fst happy_var_1)) (reverse (fst happy_var_3))+	)}}}++happyReduce_234 = happyMonadReduce 4# 89# happyReduction_234+happyReduction_234 (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 { (Loc happy_var_1 KW_Where) -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftCurly) -> +	case happyOut101 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (Loc happy_var_4 RightCurly) -> +	( return (fst happy_var_3, happy_var_1 : happy_var_2 : snd happy_var_3 ++ [happy_var_4], Just $ happy_var_1 <^^> happy_var_4))}}}}+	) (\r -> happyReturn (happyIn100 r))++happyReduce_235 = happyMonadReduce 4# 89# happyReduction_235+happyReduction_235 (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 { (Loc happy_var_1 KW_Where) -> +	case happyOut225 happy_x_2 of { happy_var_2 -> +	case happyOut101 happy_x_3 of { happy_var_3 -> +	case happyOut226 happy_x_4 of { happy_var_4 -> +	( return (fst happy_var_3, happy_var_1 : happy_var_2 : snd happy_var_3 ++ [happy_var_4], Just $ happy_var_1 <^^> happy_var_4))}}}}+	) (\r -> happyReturn (happyIn100 r))++happyReduce_236 = happyMonadReduce 0# 89# happyReduction_236+happyReduction_236 (happyRest) tk+	 = happyThen (( checkEnabled EmptyDataDecls >> return ([],[],Nothing))+	) (\r -> happyReturn (happyIn100 r))++happyReduce_237 = happySpecReduce_3  90# happyReduction_237+happyReduction_237 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut25 happy_x_1 of { happy_var_1 -> +	case happyOut102 happy_x_2 of { happy_var_2 -> +	case happyOut25 happy_x_3 of { happy_var_3 -> +	happyIn101+		 ((fst happy_var_2, reverse happy_var_1 ++ snd happy_var_2 ++ reverse happy_var_3)+	)}}}++happyReduce_238 = happySpecReduce_3  91# happyReduction_238+happyReduction_238 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut102 happy_x_1 of { happy_var_1 -> +	case happyOut24 happy_x_2 of { happy_var_2 -> +	case happyOut103 happy_x_3 of { happy_var_3 -> +	happyIn102+		 ((happy_var_3 : fst happy_var_1, snd happy_var_1 ++ reverse happy_var_2)+	)}}}++happyReduce_239 = happySpecReduce_1  91# happyReduction_239+happyReduction_239 happy_x_1+	 =  case happyOut103 happy_x_1 of { happy_var_1 -> +	happyIn102+		 (([happy_var_1],[])+	)}++happyReduce_240 = happyMonadReduce 3# 92# happyReduction_240+happyReduction_240 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut201 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 DoubleColon) -> +	case happyOut88 happy_x_3 of { happy_var_3 -> +	( do { c <- checkUnQual happy_var_1;+                                               return $ GadtDecl (happy_var_1 <> happy_var_3 <** [happy_var_2]) c happy_var_3 })}}}+	) (\r -> happyReturn (happyIn103 r))++happyReduce_241 = happySpecReduce_2  93# happyReduction_241+happyReduction_241 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Equals) -> +	case happyOut105 happy_x_2 of { happy_var_2 -> +	happyIn104+		 (let (ds,ss,l) = happy_var_2 in (ds, happy_var_1 : reverse ss, Just $ nIS happy_var_1 <++> l)+	)}}++happyReduce_242 = happySpecReduce_3  94# happyReduction_242+happyReduction_242 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut105 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 Bar) -> +	case happyOut106 happy_x_3 of { happy_var_3 -> +	happyIn105+		 (let (ds,ss,l) = happy_var_1 in (happy_var_3 : ds, happy_var_2 : ss, l <++> ann happy_var_3)+	)}}}++happyReduce_243 = happySpecReduce_1  94# happyReduction_243+happyReduction_243 happy_x_1+	 =  case happyOut106 happy_x_1 of { happy_var_1 -> +	happyIn105+		 (([happy_var_1],[],ann happy_var_1)+	)}++happyReduce_244 = happyMonadReduce 3# 95# happyReduction_244+happyReduction_244 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut107 happy_x_1 of { happy_var_1 -> +	case happyOut90 happy_x_2 of { happy_var_2 -> +	case happyOut108 happy_x_3 of { happy_var_3 -> +	( do { checkEnabled ExistentialQuantification ;+                                               ctxt <- checkContext (Just happy_var_2) ;+                                               let {(mtvs,ss,ml) = happy_var_1} ;+                                               return $ QualConDecl (ml <?+> ann happy_var_3 <** ss) mtvs ctxt happy_var_3 })}}}+	) (\r -> happyReturn (happyIn106 r))++happyReduce_245 = happySpecReduce_2  95# happyReduction_245+happyReduction_245 happy_x_2+	happy_x_1+	 =  case happyOut107 happy_x_1 of { happy_var_1 -> +	case happyOut108 happy_x_2 of { happy_var_2 -> +	happyIn106+		 (let (mtvs, ss, ml) = happy_var_1 in QualConDecl (ml <?+> ann happy_var_2 <** ss) mtvs Nothing happy_var_2+	)}}++happyReduce_246 = happyMonadReduce 3# 96# happyReduction_246+happyReduction_246 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Forall) -> +	case happyOut93 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 Dot) -> +	( checkEnabled ExistentialQuantification >> return (Just (fst happy_var_2), [happy_var_1,happy_var_3], Just $ happy_var_1 <^^> happy_var_3))}}}+	) (\r -> happyReturn (happyIn107 r))++happyReduce_247 = happySpecReduce_0  96# happyReduction_247+happyReduction_247  =  happyIn107+		 ((Nothing, [], Nothing)+	)++happyReduce_248 = happySpecReduce_1  97# happyReduction_248+happyReduction_248 happy_x_1+	 =  case happyOut109 happy_x_1 of { happy_var_1 -> +	happyIn108+		 (let (n,ts,l) = happy_var_1 in ConDecl l n ts+	)}++happyReduce_249 = happySpecReduce_3  97# happyReduction_249+happyReduction_249 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut112 happy_x_1 of { happy_var_1 -> +	case happyOut205 happy_x_2 of { happy_var_2 -> +	case happyOut112 happy_x_3 of { happy_var_3 -> +	happyIn108+		 (InfixConDecl (happy_var_1 <> happy_var_3) happy_var_1 happy_var_2 happy_var_3+	)}}}++happyReduce_250 = happyMonadReduce 3# 97# happyReduction_250+happyReduction_250 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut201 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftCurly) -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightCurly) -> +	( do { c <- checkUnQual happy_var_1; return $ RecDecl (ann happy_var_1 <++> nIS happy_var_3 <** [happy_var_2,happy_var_3]) c [] })}}}+	) (\r -> happyReturn (happyIn108 r))++happyReduce_251 = happyMonadReduce 4# 97# happyReduction_251+happyReduction_251 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut201 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftCurly) -> +	case happyOut113 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (Loc happy_var_4 RightCurly) -> +	( do { c <- checkUnQual happy_var_1;+                                              return $ RecDecl (ann happy_var_1 <++> nIS happy_var_4 <** (happy_var_2:reverse (snd happy_var_3) ++ [happy_var_4])) c (reverse (fst happy_var_3)) })}}}}+	) (\r -> happyReturn (happyIn108 r))++happyReduce_252 = happyMonadReduce 1# 98# happyReduction_252+happyReduction_252 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut82 happy_x_1 of { happy_var_1 -> +	( do { (c,ts) <- splitTyConApp happy_var_1;+                                              return (c,map (\t -> UnBangedTy (ann t) t) ts,ann happy_var_1) })}+	) (\r -> happyReturn (happyIn109 r))++happyReduce_253 = happySpecReduce_1  98# happyReduction_253+happyReduction_253 happy_x_1+	 =  case happyOut110 happy_x_1 of { happy_var_1 -> +	happyIn109+		 (happy_var_1+	)}++happyReduce_254 = happyMonadReduce 3# 99# happyReduction_254+happyReduction_254 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut82 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 Exclamation) -> +	case happyOut83 happy_x_3 of { happy_var_3 -> +	( do { (c,ts) <- splitTyConApp happy_var_1;+                                                          return (c,map (\t -> UnBangedTy (ann t) t) ts+++                                                                  [BangedTy (nIS happy_var_2 <++> ann happy_var_3 <** [happy_var_2]) happy_var_3], happy_var_1 <> happy_var_3) })}}}+	) (\r -> happyReturn (happyIn110 r))++happyReduce_255 = happyMonadReduce 5# 99# happyReduction_255+happyReduction_255 (happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut82 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 UNPACK) -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 PragmaEnd) -> +	case happyOutTok happy_x_4 of { (Loc happy_var_4 Exclamation) -> +	case happyOut83 happy_x_5 of { happy_var_5 -> +	( do { (c,ts) <- splitTyConApp happy_var_1;+                                                          return (c,map (\t -> UnBangedTy (ann t) t) ts+++                                                                  [UnpackedTy (nIS happy_var_2 <++> ann happy_var_5 <** [happy_var_2,happy_var_3,happy_var_4]) happy_var_5], happy_var_1 <> happy_var_5) })}}}}}+	) (\r -> happyReturn (happyIn110 r))++happyReduce_256 = happySpecReduce_2  99# happyReduction_256+happyReduction_256 happy_x_2+	happy_x_1+	 =  case happyOut110 happy_x_1 of { happy_var_1 -> +	case happyOut111 happy_x_2 of { happy_var_2 -> +	happyIn110+		 (let (n,ts,l) = happy_var_1 in (n, ts ++ [happy_var_2],l <++> ann happy_var_2)+	)}}++happyReduce_257 = happySpecReduce_1  100# happyReduction_257+happyReduction_257 happy_x_1+	 =  case happyOut83 happy_x_1 of { happy_var_1 -> +	happyIn111+		 (UnBangedTy (ann happy_var_1) happy_var_1+	)}++happyReduce_258 = happySpecReduce_2  100# happyReduction_258+happyReduction_258 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Exclamation) -> +	case happyOut83 happy_x_2 of { happy_var_2 -> +	happyIn111+		 (BangedTy   (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2+	)}}++happyReduce_259 = happyReduce 4# 100# happyReduction_259+happyReduction_259 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 UNPACK) -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 PragmaEnd) -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 Exclamation) -> +	case happyOut83 happy_x_4 of { happy_var_4 -> +	happyIn111+		 (UnpackedTy (nIS happy_var_1 <++> ann happy_var_4 <** [happy_var_1,happy_var_2,happy_var_3]) happy_var_4+	) `HappyStk` happyRest}}}}++happyReduce_260 = happySpecReduce_1  101# happyReduction_260+happyReduction_260 happy_x_1+	 =  case happyOut81 happy_x_1 of { happy_var_1 -> +	happyIn112+		 (UnBangedTy (ann happy_var_1) happy_var_1+	)}++happyReduce_261 = happySpecReduce_2  101# happyReduction_261+happyReduction_261 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Exclamation) -> +	case happyOut83 happy_x_2 of { happy_var_2 -> +	happyIn112+		 (BangedTy   (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2+	)}}++happyReduce_262 = happyReduce 4# 101# 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 { (Loc happy_var_1 UNPACK) -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 PragmaEnd) -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 Exclamation) -> +	case happyOut83 happy_x_4 of { happy_var_4 -> +	happyIn112+		 (UnpackedTy (nIS happy_var_1 <++> ann happy_var_4 <** [happy_var_1,happy_var_2,happy_var_3]) happy_var_4+	) `HappyStk` happyRest}}}}++happyReduce_263 = happySpecReduce_3  102# happyReduction_263+happyReduction_263 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut113 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> +	case happyOut114 happy_x_3 of { happy_var_3 -> +	happyIn113+		 ((happy_var_3 : fst happy_var_1, happy_var_2 : snd happy_var_1)+	)}}}++happyReduce_264 = happySpecReduce_1  102# happyReduction_264+happyReduction_264 happy_x_1+	 =  case happyOut114 happy_x_1 of { happy_var_1 -> +	happyIn113+		 (([happy_var_1],[])+	)}++happyReduce_265 = happySpecReduce_3  103# happyReduction_265+happyReduction_265 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut62 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 DoubleColon) -> +	case happyOut115 happy_x_3 of { happy_var_3 -> +	happyIn114+		 (let (ns,ss,l) = happy_var_1 in FieldDecl (l <++> ann happy_var_3 <** (reverse ss ++ [happy_var_2])) (reverse ns) happy_var_3+	)}}}++happyReduce_266 = happySpecReduce_1  104# happyReduction_266+happyReduction_266 happy_x_1+	 =  case happyOut88 happy_x_1 of { happy_var_1 -> +	happyIn115+		 (UnBangedTy (ann happy_var_1) happy_var_1+	)}++happyReduce_267 = happySpecReduce_2  104# happyReduction_267+happyReduction_267 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Exclamation) -> +	case happyOut83 happy_x_2 of { happy_var_2 -> +	happyIn115+		 (BangedTy   (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2+	)}}++happyReduce_268 = happyReduce 4# 104# happyReduction_268+happyReduction_268 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 UNPACK) -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 PragmaEnd) -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 Exclamation) -> +	case happyOut83 happy_x_4 of { happy_var_4 -> +	happyIn115+		 (UnpackedTy (nIS happy_var_1 <++> ann happy_var_4 <** [happy_var_1,happy_var_2,happy_var_3]) happy_var_4+	) `HappyStk` happyRest}}}}++happyReduce_269 = happySpecReduce_0  105# happyReduction_269+happyReduction_269  =  happyIn116+		 (Nothing+	)++happyReduce_270 = happySpecReduce_2  105# happyReduction_270+happyReduction_270 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Deriving) -> +	case happyOut118 happy_x_2 of { happy_var_2 -> +	happyIn116+		 (let l = nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1] in Just $ Deriving l [IHead (ann happy_var_2) happy_var_2 []]+	)}}++happyReduce_271 = happySpecReduce_3  105# happyReduction_271+happyReduction_271 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Deriving) -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftParen) -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> +	happyIn116+		 (Just $ Deriving (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_2,happy_var_3]) []+	)}}}++happyReduce_272 = happyReduce 4# 105# happyReduction_272+happyReduction_272 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Deriving) -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftParen) -> +	case happyOut117 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (Loc happy_var_4 RightParen) -> +	happyIn116+		 (Just $ Deriving (happy_var_1 <^^> happy_var_4 <** happy_var_1:happy_var_2: reverse (snd happy_var_3) ++ [happy_var_4]) (reverse (fst happy_var_3))+	) `HappyStk` happyRest}}}}++happyReduce_273 = happyMonadReduce 1# 106# happyReduction_273+happyReduction_273 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut92 happy_x_1 of { happy_var_1 -> +	( checkDeriving (fst happy_var_1) >>= \ds -> return (ds, snd happy_var_1))}+	) (\r -> happyReturn (happyIn117 r))++happyReduce_274 = happySpecReduce_1  107# happyReduction_274+happyReduction_274 happy_x_1+	 =  case happyOut215 happy_x_1 of { happy_var_1 -> +	happyIn118+		 (happy_var_1+	)}++happyReduce_275 = happyMonadReduce 1# 108# happyReduction_275+happyReduction_275 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut120 happy_x_1 of { happy_var_1 -> +	( checkEnabled KindSignatures >> return happy_var_1)}+	) (\r -> happyReturn (happyIn119 r))++happyReduce_276 = happySpecReduce_1  109# happyReduction_276+happyReduction_276 happy_x_1+	 =  case happyOut121 happy_x_1 of { happy_var_1 -> +	happyIn120+		 (happy_var_1+	)}++happyReduce_277 = happySpecReduce_3  109# happyReduction_277+happyReduction_277 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut121 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 RightArrow) -> +	case happyOut120 happy_x_3 of { happy_var_3 -> +	happyIn120+		 (KindFn (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3+	)}}}++happyReduce_278 = happySpecReduce_1  110# happyReduction_278+happyReduction_278 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Star) -> +	happyIn121+		 (KindStar  (nIS happy_var_1)+	)}++happyReduce_279 = happySpecReduce_1  110# happyReduction_279+happyReduction_279 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Exclamation) -> +	happyIn121+		 (KindBang  (nIS happy_var_1)+	)}++happyReduce_280 = happySpecReduce_3  110# happyReduction_280+happyReduction_280 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> +	case happyOut120 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> +	happyIn121+		 (KindParen (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3]) happy_var_2+	)}}}++happyReduce_281 = happySpecReduce_0  111# happyReduction_281+happyReduction_281  =  happyIn122+		 ((Nothing,[])+	)++happyReduce_282 = happySpecReduce_2  111# happyReduction_282+happyReduction_282 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 DoubleColon) -> +	case happyOut119 happy_x_2 of { happy_var_2 -> +	happyIn122+		 ((Just happy_var_2,[happy_var_1])+	)}}++happyReduce_283 = happyMonadReduce 4# 112# happyReduction_283+happyReduction_283 (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 { (Loc happy_var_1 KW_Where) -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftCurly) -> +	case happyOut124 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (Loc happy_var_4 RightCurly) -> +	( checkClassBody (fst happy_var_3) >>= \vs -> return (Just vs, happy_var_1:happy_var_2: snd happy_var_3 ++ [happy_var_4], Just (happy_var_1 <^^> happy_var_4)))}}}}+	) (\r -> happyReturn (happyIn123 r))++happyReduce_284 = happyMonadReduce 4# 112# happyReduction_284+happyReduction_284 (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 { (Loc happy_var_1 KW_Where) -> +	case happyOut225 happy_x_2 of { happy_var_2 -> +	case happyOut124 happy_x_3 of { happy_var_3 -> +	case happyOut226 happy_x_4 of { happy_var_4 -> +	( checkClassBody (fst happy_var_3) >>= \vs -> return (Just vs, happy_var_1:happy_var_2: snd happy_var_3 ++ [happy_var_4], Just (happy_var_1 <^^> happy_var_4)))}}}}+	) (\r -> happyReturn (happyIn123 r))++happyReduce_285 = happySpecReduce_0  112# happyReduction_285+happyReduction_285  =  happyIn123+		 ((Nothing,[],Nothing)+	)++happyReduce_286 = happyMonadReduce 3# 113# happyReduction_286+happyReduction_286 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut25 happy_x_1 of { happy_var_1 -> +	case happyOut125 happy_x_2 of { happy_var_2 -> +	case happyOut25 happy_x_3 of { happy_var_3 -> +	( checkRevClsDecls (fst happy_var_2) >>= \cs -> return (cs, reverse happy_var_1 ++ snd happy_var_2 ++ reverse happy_var_3))}}}+	) (\r -> happyReturn (happyIn124 r))++happyReduce_287 = happySpecReduce_1  113# happyReduction_287+happyReduction_287 happy_x_1+	 =  case happyOut25 happy_x_1 of { happy_var_1 -> +	happyIn124+		 (([],reverse happy_var_1)+	)}++happyReduce_288 = happySpecReduce_3  114# happyReduction_288+happyReduction_288 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut125 happy_x_1 of { happy_var_1 -> +	case happyOut24 happy_x_2 of { happy_var_2 -> +	case happyOut126 happy_x_3 of { happy_var_3 -> +	happyIn125+		 ((happy_var_3 : fst happy_var_1, snd happy_var_1 ++ reverse happy_var_2)+	)}}}++happyReduce_289 = happySpecReduce_1  114# happyReduction_289+happyReduction_289 happy_x_1+	 =  case happyOut126 happy_x_1 of { happy_var_1 -> +	happyIn125+		 (([happy_var_1],[])+	)}++happyReduce_290 = happySpecReduce_1  115# happyReduction_290+happyReduction_290 happy_x_1+	 =  case happyOut55 happy_x_1 of { happy_var_1 -> +	happyIn126+		 (ClsDecl (ann happy_var_1) happy_var_1+	)}++happyReduce_291 = happyMonadReduce 1# 115# happyReduction_291+happyReduction_291 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut127 happy_x_1 of { happy_var_1 -> +	( checkEnabled TypeFamilies >> return happy_var_1)}+	) (\r -> happyReturn (happyIn126 r))++happyReduce_292 = happyMonadReduce 3# 116# happyReduction_292+happyReduction_292 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Type) -> +	case happyOut80 happy_x_2 of { happy_var_2 -> +	case happyOut122 happy_x_3 of { happy_var_3 -> +	( do { dh <- checkSimpleType happy_var_2;+                    return (ClsTyFam  (nIS happy_var_1 <++> ann happy_var_2 <+?> (fmap ann) (fst happy_var_3) <** happy_var_1:snd happy_var_3) dh (fst happy_var_3)) })}}}+	) (\r -> happyReturn (happyIn127 r))++happyReduce_293 = happyReduce 4# 116# happyReduction_293+happyReduction_293 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Type) -> +	case happyOut77 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 Equals) -> +	case happyOut88 happy_x_4 of { happy_var_4 -> +	happyIn127+		 (ClsTyDef (nIS happy_var_1 <++> ann happy_var_4 <** [happy_var_1,happy_var_3]) happy_var_2 happy_var_4+	) `HappyStk` happyRest}}}}++happyReduce_294 = happyMonadReduce 3# 116# happyReduction_294+happyReduction_294 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Data) -> +	case happyOut89 happy_x_2 of { happy_var_2 -> +	case happyOut122 happy_x_3 of { happy_var_3 -> +	( do { (cs,dh) <- checkDataHeader happy_var_2;+                    return (ClsDataFam (nIS happy_var_1 <++> ann happy_var_2 <+?> (fmap ann) (fst happy_var_3) <** happy_var_1:snd happy_var_3) cs dh (fst happy_var_3)) })}}}+	) (\r -> happyReturn (happyIn127 r))++happyReduce_295 = happyMonadReduce 4# 117# happyReduction_295+happyReduction_295 (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 { (Loc happy_var_1 KW_Where) -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftCurly) -> +	case happyOut129 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (Loc happy_var_4 RightCurly) -> +	( checkInstBody (fst happy_var_3) >>= \vs -> return (Just vs, happy_var_1:happy_var_2: snd happy_var_3 ++ [happy_var_4], Just (happy_var_1 <^^> happy_var_4)))}}}}+	) (\r -> happyReturn (happyIn128 r))++happyReduce_296 = happyMonadReduce 4# 117# happyReduction_296+happyReduction_296 (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 { (Loc happy_var_1 KW_Where) -> +	case happyOut225 happy_x_2 of { happy_var_2 -> +	case happyOut129 happy_x_3 of { happy_var_3 -> +	case happyOut226 happy_x_4 of { happy_var_4 -> +	( checkInstBody (fst happy_var_3) >>= \vs -> return (Just vs, happy_var_1:happy_var_2: snd happy_var_3 ++ [happy_var_4], Just (happy_var_1 <^^> happy_var_4)))}}}}+	) (\r -> happyReturn (happyIn128 r))++happyReduce_297 = happySpecReduce_0  117# happyReduction_297+happyReduction_297  =  happyIn128+		 ((Nothing, [], Nothing)+	)++happyReduce_298 = happyMonadReduce 3# 118# happyReduction_298+happyReduction_298 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut25 happy_x_1 of { happy_var_1 -> +	case happyOut130 happy_x_2 of { happy_var_2 -> +	case happyOut25 happy_x_3 of { happy_var_3 -> +	( checkRevInstDecls (fst happy_var_2) >>= \is -> return (is, reverse happy_var_1 ++ snd happy_var_2 ++ reverse happy_var_3))}}}+	) (\r -> happyReturn (happyIn129 r))++happyReduce_299 = happySpecReduce_1  118# happyReduction_299+happyReduction_299 happy_x_1+	 =  case happyOut25 happy_x_1 of { happy_var_1 -> +	happyIn129+		 (([],reverse happy_var_1)+	)}++happyReduce_300 = happySpecReduce_3  119# happyReduction_300+happyReduction_300 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut130 happy_x_1 of { happy_var_1 -> +	case happyOut24 happy_x_2 of { happy_var_2 -> +	case happyOut131 happy_x_3 of { happy_var_3 -> +	happyIn130+		 ((happy_var_3 : fst happy_var_1, snd happy_var_1 ++ reverse happy_var_2)+	)}}}++happyReduce_301 = happySpecReduce_1  119# happyReduction_301+happyReduction_301 happy_x_1+	 =  case happyOut131 happy_x_1 of { happy_var_1 -> +	happyIn130+		 (([happy_var_1],[])+	)}++happyReduce_302 = happySpecReduce_1  120# happyReduction_302+happyReduction_302 happy_x_1+	 =  case happyOut133 happy_x_1 of { happy_var_1 -> +	happyIn131+		 (InsDecl (ann happy_var_1) happy_var_1+	)}++happyReduce_303 = happyMonadReduce 1# 120# happyReduction_303+happyReduction_303 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut132 happy_x_1 of { happy_var_1 -> +	( checkEnabled TypeFamilies >> return happy_var_1)}+	) (\r -> happyReturn (happyIn131 r))++happyReduce_304 = happySpecReduce_1  120# happyReduction_304+happyReduction_304 happy_x_1+	 =  case happyOut58 happy_x_1 of { happy_var_1 -> +	happyIn131+		 (InsDecl (ann happy_var_1) happy_var_1+	)}++happyReduce_305 = happyMonadReduce 4# 121# happyReduction_305+happyReduction_305 (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 { (Loc happy_var_1 KW_Type) -> +	case happyOut77 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 Equals) -> +	case happyOut88 happy_x_4 of { happy_var_4 -> +	( do { -- no checkSimpleType happy_var_4 since dtype may contain type patterns+                       return (InsType (nIS happy_var_1 <++> ann happy_var_4 <** [happy_var_1,happy_var_3]) happy_var_2 happy_var_4) })}}}}+	) (\r -> happyReturn (happyIn132 r))++happyReduce_306 = happyMonadReduce 4# 121# happyReduction_306+happyReduction_306 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut51 happy_x_1 of { happy_var_1 -> +	case happyOut88 happy_x_2 of { happy_var_2 -> +	case happyOut104 happy_x_3 of { happy_var_3 -> +	case happyOut116 happy_x_4 of { happy_var_4 -> +	( do { -- (cs,c,t) <- checkDataHeader happy_var_4;+                       let {(ds,ss,minf) = happy_var_3};+                       checkDataOrNew happy_var_1 ds;+                       return (InsData (happy_var_1 <> happy_var_2 <+?> minf <+?> fmap ann happy_var_4 <** ss ) happy_var_1 happy_var_2 (reverse ds) happy_var_4) })}}}}+	) (\r -> happyReturn (happyIn132 r))++happyReduce_307 = happyMonadReduce 5# 121# happyReduction_307+happyReduction_307 (happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut51 happy_x_1 of { happy_var_1 -> +	case happyOut88 happy_x_2 of { happy_var_2 -> +	case happyOut122 happy_x_3 of { happy_var_3 -> +	case happyOut100 happy_x_4 of { happy_var_4 -> +	case happyOut116 happy_x_5 of { happy_var_5 -> +	( do { -- (cs,c,t) <- checkDataHeader happy_var_4;+                       let { (gs,ss,minf) = happy_var_4 } ;+                       checkDataOrNewG happy_var_1 gs;+                       return $ InsGData (ann happy_var_1 <+?> minf <+?> fmap ann happy_var_5 <** (snd happy_var_3 ++ ss)) happy_var_1 happy_var_2 (fst happy_var_3) (reverse gs) happy_var_5 })}}}}}+	) (\r -> happyReturn (happyIn132 r))++happyReduce_308 = happyMonadReduce 4# 122# happyReduction_308+happyReduction_308 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut143 happy_x_1 of { happy_var_1 -> +	case happyOut135 happy_x_2 of { happy_var_2 -> +	case happyOut136 happy_x_3 of { happy_var_3 -> +	case happyOut134 happy_x_4 of { happy_var_4 -> +	( checkValDef ((happy_var_1 <> happy_var_3 <+?> (fmap ann) (fst happy_var_4)) <** (snd happy_var_2 ++ snd happy_var_4)) happy_var_1 (fst happy_var_2) happy_var_3 (fst happy_var_4))}}}}+	) (\r -> happyReturn (happyIn133 r))++happyReduce_309 = happyMonadReduce 4# 122# happyReduction_309+happyReduction_309 (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 { (Loc happy_var_1 Exclamation) -> +	case happyOut152 happy_x_2 of { happy_var_2 -> +	case happyOut136 happy_x_3 of { happy_var_3 -> +	case happyOut134 happy_x_4 of { happy_var_4 -> +	( do { checkEnabled BangPatterns ;+                                              let { l = nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1] };+                                              p <- checkPattern (BangPat l happy_var_2);+                                              return $ PatBind (p <> happy_var_3 <+?> (fmap ann) (fst happy_var_4) <** snd happy_var_4)+                                                          p Nothing happy_var_3 (fst happy_var_4) })}}}}+	) (\r -> happyReturn (happyIn133 r))++happyReduce_310 = happySpecReduce_2  123# happyReduction_310+happyReduction_310 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Where) -> +	case happyOut61 happy_x_2 of { happy_var_2 -> +	happyIn134+		 ((Just happy_var_2, [happy_var_1])+	)}}++happyReduce_311 = happySpecReduce_0  123# happyReduction_311+happyReduction_311  =  happyIn134+		 ((Nothing, [])+	)++happyReduce_312 = happyMonadReduce 2# 124# happyReduction_312+happyReduction_312 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 DoubleColon) -> +	case happyOut88 happy_x_2 of { happy_var_2 -> +	( checkEnabled ScopedTypeVariables >> return (Just happy_var_2, [happy_var_1]))}}+	) (\r -> happyReturn (happyIn135 r))++happyReduce_313 = happySpecReduce_0  124# happyReduction_313+happyReduction_313  =  happyIn135+		 ((Nothing,[])+	)++happyReduce_314 = happySpecReduce_2  125# happyReduction_314+happyReduction_314 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Equals) -> +	case happyOut139 happy_x_2 of { happy_var_2 -> +	happyIn136+		 (UnGuardedRhs (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2+	)}}++happyReduce_315 = happySpecReduce_1  125# happyReduction_315+happyReduction_315 happy_x_1+	 =  case happyOut137 happy_x_1 of { happy_var_1 -> +	happyIn136+		 (GuardedRhss (snd happy_var_1) (reverse $ fst happy_var_1)+	)}++happyReduce_316 = happySpecReduce_2  126# happyReduction_316+happyReduction_316 happy_x_2+	happy_x_1+	 =  case happyOut137 happy_x_1 of { happy_var_1 -> +	case happyOut138 happy_x_2 of { happy_var_2 -> +	happyIn137+		 ((happy_var_2 : fst happy_var_1, snd happy_var_1 <++> ann happy_var_2)+	)}}++happyReduce_317 = happySpecReduce_1  126# happyReduction_317+happyReduction_317 happy_x_1+	 =  case happyOut138 happy_x_1 of { happy_var_1 -> +	happyIn137+		 (([happy_var_1],ann happy_var_1)+	)}++happyReduce_318 = happyMonadReduce 4# 127# happyReduction_318+happyReduction_318 (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 { (Loc happy_var_1 Bar) -> +	case happyOut176 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 Equals) -> +	case happyOut139 happy_x_4 of { happy_var_4 -> +	( do { checkPatternGuards (fst happy_var_2);+                                       return $ GuardedRhs (nIS happy_var_1 <++> ann happy_var_4 <** (happy_var_1:snd happy_var_2 ++ [happy_var_3])) (reverse (fst happy_var_2)) happy_var_4 })}}}}+	) (\r -> happyReturn (happyIn138 r))++happyReduce_319 = happyMonadReduce 1# 128# happyReduction_319+happyReduction_319 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut140 happy_x_1 of { happy_var_1 -> +	( checkExpr happy_var_1)}+	) (\r -> happyReturn (happyIn139 r))++happyReduce_320 = happySpecReduce_3  129# happyReduction_320+happyReduction_320 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut143 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 DoubleColon) -> +	case happyOut88 happy_x_3 of { happy_var_3 -> +	happyIn140+		 (ExpTypeSig      (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3+	)}}}++happyReduce_321 = happySpecReduce_1  129# happyReduction_321+happyReduction_321 happy_x_1+	 =  case happyOut141 happy_x_1 of { happy_var_1 -> +	happyIn140+		 (happy_var_1+	)}++happyReduce_322 = happySpecReduce_2  129# happyReduction_322+happyReduction_322 happy_x_2+	happy_x_1+	 =  case happyOut143 happy_x_1 of { happy_var_1 -> +	case happyOut208 happy_x_2 of { happy_var_2 -> +	happyIn140+		 (PostOp          (happy_var_1 <> happy_var_2)          happy_var_1 happy_var_2+	)}}++happyReduce_323 = happySpecReduce_3  129# happyReduction_323+happyReduction_323 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut143 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftArrowTail) -> +	case happyOut140 happy_x_3 of { happy_var_3 -> +	happyIn140+		 (LeftArrApp      (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3+	)}}}++happyReduce_324 = happySpecReduce_3  129# happyReduction_324+happyReduction_324 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut143 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 RightArrowTail) -> +	case happyOut140 happy_x_3 of { happy_var_3 -> +	happyIn140+		 (RightArrApp     (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3+	)}}}++happyReduce_325 = happySpecReduce_3  129# happyReduction_325+happyReduction_325 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut143 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftDblArrowTail) -> +	case happyOut140 happy_x_3 of { happy_var_3 -> +	happyIn140+		 (LeftArrHighApp  (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3+	)}}}++happyReduce_326 = happySpecReduce_3  129# happyReduction_326+happyReduction_326 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut143 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 RightDblArrowTail) -> +	case happyOut140 happy_x_3 of { happy_var_3 -> +	happyIn140+		 (RightArrHighApp (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3+	)}}}++happyReduce_327 = happySpecReduce_1  130# happyReduction_327+happyReduction_327 happy_x_1+	 =  case happyOut142 happy_x_1 of { happy_var_1 -> +	happyIn141+		 (happy_var_1+	)}++happyReduce_328 = happySpecReduce_1  130# happyReduction_328+happyReduction_328 happy_x_1+	 =  case happyOut143 happy_x_1 of { happy_var_1 -> +	happyIn141+		 (happy_var_1+	)}++happyReduce_329 = happySpecReduce_3  131# happyReduction_329+happyReduction_329 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut143 happy_x_1 of { happy_var_1 -> +	case happyOut208 happy_x_2 of { happy_var_2 -> +	case happyOut144 happy_x_3 of { happy_var_3 -> +	happyIn142+		 (InfixApp (happy_var_1 <> happy_var_3) happy_var_1 happy_var_2 happy_var_3+	)}}}++happyReduce_330 = happySpecReduce_1  131# happyReduction_330+happyReduction_330 happy_x_1+	 =  case happyOut144 happy_x_1 of { happy_var_1 -> +	happyIn142+		 (happy_var_1+	)}++happyReduce_331 = happySpecReduce_3  132# happyReduction_331+happyReduction_331 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut143 happy_x_1 of { happy_var_1 -> +	case happyOut208 happy_x_2 of { happy_var_2 -> +	case happyOut147 happy_x_3 of { happy_var_3 -> +	happyIn143+		 (InfixApp (happy_var_1 <> happy_var_3) happy_var_1 happy_var_2 happy_var_3+	)}}}++happyReduce_332 = happySpecReduce_1  132# happyReduction_332+happyReduction_332 happy_x_1+	 =  case happyOut147 happy_x_1 of { happy_var_1 -> +	happyIn143+		 (happy_var_1+	)}++happyReduce_333 = happyReduce 4# 133# happyReduction_333+happyReduction_333 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 Backslash) -> +	case happyOut150 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightArrow) -> +	case happyOut140 happy_x_4 of { happy_var_4 -> +	happyIn144+		 (Lambda (nIS happy_var_1 <++> ann happy_var_4 <** [happy_var_1,happy_var_3]) (reverse happy_var_2) happy_var_4+	) `HappyStk` happyRest}}}}++happyReduce_334 = happyReduce 4# 133# happyReduction_334+happyReduction_334 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Let) -> +	case happyOut61 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 KW_In) -> +	case happyOut140 happy_x_4 of { happy_var_4 -> +	happyIn144+		 (Let    (nIS happy_var_1 <++> ann happy_var_4 <** [happy_var_1,happy_var_3])    happy_var_2 happy_var_4+	) `HappyStk` happyRest}}}}++happyReduce_335 = happyReduce 8# 133# happyReduction_335+happyReduction_335 (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 happyOutTok happy_x_1 of { (Loc happy_var_1 KW_If) -> +	case happyOut140 happy_x_2 of { happy_var_2 -> +	case happyOut145 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (Loc happy_var_4 KW_Then) -> +	case happyOut140 happy_x_5 of { happy_var_5 -> +	case happyOut145 happy_x_6 of { happy_var_6 -> +	case happyOutTok happy_x_7 of { (Loc happy_var_7 KW_Else) -> +	case happyOut140 happy_x_8 of { happy_var_8 -> +	happyIn144+		 (If     (nIS happy_var_1 <++> ann happy_var_8 <** (happy_var_1:happy_var_3 ++ happy_var_4:happy_var_6 ++ [happy_var_7])) happy_var_2 happy_var_5 happy_var_8+	) `HappyStk` happyRest}}}}}}}}++happyReduce_336 = happyReduce 4# 133# happyReduction_336+happyReduction_336 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Proc) -> +	case happyOut151 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightArrow) -> +	case happyOut140 happy_x_4 of { happy_var_4 -> +	happyIn144+		 (Proc   (nIS happy_var_1 <++> ann happy_var_4 <** [happy_var_1,happy_var_3])    happy_var_2 happy_var_4+	) `HappyStk` happyRest}}}}++happyReduce_337 = happySpecReduce_1  133# happyReduction_337+happyReduction_337 happy_x_1+	 =  case happyOut148 happy_x_1 of { happy_var_1 -> +	happyIn144+		 (happy_var_1+	)}++happyReduce_338 = happyMonadReduce 1# 134# happyReduction_338+happyReduction_338 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 SemiColon) -> +	( checkEnabled DoAndIfThenElse >> return [happy_var_1])}+	) (\r -> happyReturn (happyIn145 r))++happyReduce_339 = happySpecReduce_0  134# happyReduction_339+happyReduction_339  =  happyIn145+		 ([]+	)++happyReduce_340 = happySpecReduce_1  135# happyReduction_340+happyReduction_340 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 SemiColon) -> +	happyIn146+		 ([happy_var_1]+	)}++happyReduce_341 = happySpecReduce_0  135# happyReduction_341+happyReduction_341  =  happyIn146+		 ([]+	)++happyReduce_342 = happyReduce 4# 136# happyReduction_342+happyReduction_342 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Case) -> +	case happyOut140 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 KW_Of) -> +	case happyOut178 happy_x_4 of { happy_var_4 -> +	happyIn147+		 (let (als, inf, ss) = happy_var_4 in Case (nIS happy_var_1 <++> inf <** (happy_var_1:happy_var_3:ss)) happy_var_2 als+	) `HappyStk` happyRest}}}}++happyReduce_343 = happySpecReduce_2  136# happyReduction_343+happyReduction_343 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Minus) -> +	case happyOut149 happy_x_2 of { happy_var_2 -> +	happyIn147+		 (NegApp (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2+	)}}++happyReduce_344 = happySpecReduce_2  136# happyReduction_344+happyReduction_344 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Do) -> +	case happyOut186 happy_x_2 of { happy_var_2 -> +	happyIn147+		 (let (sts, inf, ss) = happy_var_2 in Do   (nIS happy_var_1 <++> inf <** happy_var_1:ss) sts+	)}}++happyReduce_345 = happySpecReduce_2  136# happyReduction_345+happyReduction_345 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_MDo) -> +	case happyOut186 happy_x_2 of { happy_var_2 -> +	happyIn147+		 (let (sts, inf, ss) = happy_var_2 in MDo  (nIS happy_var_1 <++> inf <** happy_var_1:ss) sts+	)}}++happyReduce_346 = happySpecReduce_1  136# happyReduction_346+happyReduction_346 happy_x_1+	 =  case happyOut149 happy_x_1 of { happy_var_1 -> +	happyIn147+		 (happy_var_1+	)}++happyReduce_347 = happyReduce 4# 137# 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 { (Loc happy_var_1 CORE) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 PragmaEnd) -> +	case happyOut140 happy_x_4 of { happy_var_4 -> +	happyIn148+		 (let Loc l (StringTok (s,_)) = happy_var_2 in CorePragma (nIS happy_var_1 <++> ann happy_var_4 <** [l,happy_var_3]) s happy_var_4+	) `HappyStk` happyRest}}}}++happyReduce_348 = happyReduce 4# 137# 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 { (Loc happy_var_1 SCC) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 PragmaEnd) -> +	case happyOut140 happy_x_4 of { happy_var_4 -> +	happyIn148+		 (let Loc l (StringTok (s,_)) = happy_var_2 in SCCPragma  (nIS happy_var_1 <++> ann happy_var_4 <** [l,happy_var_3]) s happy_var_4+	) `HappyStk` happyRest}}}}++happyReduce_349 = happyReduce 11# 137# happyReduction_349+happyReduction_349 (happy_x_11 `HappyStk`+	happy_x_10 `HappyStk`+	happy_x_9 `HappyStk`+	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 happyOutTok happy_x_1 of { (Loc happy_var_1 GENERATED) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (Loc happy_var_4 Colon) -> +	case happyOutTok happy_x_5 of { happy_var_5 -> +	case happyOutTok happy_x_6 of { (Loc happy_var_6 Minus) -> +	case happyOutTok happy_x_7 of { happy_var_7 -> +	case happyOutTok happy_x_8 of { (Loc happy_var_8 Colon) -> +	case happyOutTok happy_x_9 of { happy_var_9 -> +	case happyOutTok happy_x_10 of { (Loc happy_var_10 PragmaEnd) -> +	case happyOut140 happy_x_11 of { happy_var_11 -> +	happyIn148+		 (let { Loc l0 (StringTok (s,_)) = happy_var_2;+                                                  Loc l1 (IntTok (i1,_))   = happy_var_3;+                                                  Loc l2 (IntTok (i2,_))   = happy_var_5;+                                                  Loc l3 (IntTok (i3,_))   = happy_var_7;+                                                  Loc l4 (IntTok (i4,_))   = happy_var_9}+                                             in GenPragma (nIS happy_var_1 <++> ann happy_var_11 <** [happy_var_1,l0,l1,happy_var_4,l2,happy_var_6,l3,happy_var_8,l4,happy_var_10])+                                                      s (fromInteger i1, fromInteger i2)+                                                        (fromInteger i3, fromInteger i4) happy_var_11+	) `HappyStk` happyRest}}}}}}}}}}}++happyReduce_350 = happySpecReduce_2  138# happyReduction_350+happyReduction_350 happy_x_2+	happy_x_1+	 =  case happyOut149 happy_x_1 of { happy_var_1 -> +	case happyOut152 happy_x_2 of { happy_var_2 -> +	happyIn149+		 (App (happy_var_1 <> happy_var_2) happy_var_1 happy_var_2+	)}}++happyReduce_351 = happySpecReduce_1  138# happyReduction_351+happyReduction_351 happy_x_1+	 =  case happyOut152 happy_x_1 of { happy_var_1 -> +	happyIn149+		 (happy_var_1+	)}++happyReduce_352 = happySpecReduce_2  139# happyReduction_352+happyReduction_352 happy_x_2+	happy_x_1+	 =  case happyOut150 happy_x_1 of { happy_var_1 -> +	case happyOut151 happy_x_2 of { happy_var_2 -> +	happyIn150+		 (happy_var_2 : happy_var_1+	)}}++happyReduce_353 = happySpecReduce_1  139# happyReduction_353+happyReduction_353 happy_x_1+	 =  case happyOut151 happy_x_1 of { happy_var_1 -> +	happyIn150+		 ([happy_var_1]+	)}++happyReduce_354 = happyMonadReduce 1# 140# happyReduction_354+happyReduction_354 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut152 happy_x_1 of { happy_var_1 -> +	( checkPattern happy_var_1)}+	) (\r -> happyReturn (happyIn151 r))++happyReduce_355 = happyMonadReduce 2# 140# happyReduction_355+happyReduction_355 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 Exclamation) -> +	case happyOut152 happy_x_2 of { happy_var_2 -> +	( checkPattern (BangPat (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2))}}+	) (\r -> happyReturn (happyIn151 r))++happyReduce_356 = happyMonadReduce 3# 141# happyReduction_356+happyReduction_356 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut198 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 At) -> +	case happyOut152 happy_x_3 of { happy_var_3 -> +	( do { n <- checkUnQual happy_var_1;+                                              return (AsPat (happy_var_1 <> happy_var_3 <** [happy_var_2]) n happy_var_3) })}}}+	) (\r -> happyReturn (happyIn152 r))++happyReduce_357 = happyMonadReduce 3# 141# happyReduction_357+happyReduction_357 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut198 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 RPCAt) -> +	case happyOut152 happy_x_3 of { happy_var_3 -> +	( do { n <- checkUnQual happy_var_1;+                                              return (CAsRP (happy_var_1 <> happy_var_3 <** [happy_var_2]) n happy_var_3) })}}}+	) (\r -> happyReturn (happyIn152 r))++happyReduce_358 = happySpecReduce_2  141# happyReduction_358+happyReduction_358 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Tilde) -> +	case happyOut152 happy_x_2 of { happy_var_2 -> +	happyIn152+		 (IrrPat (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2+	)}}++happyReduce_359 = happySpecReduce_1  141# happyReduction_359+happyReduction_359 happy_x_1+	 =  case happyOut153 happy_x_1 of { happy_var_1 -> +	happyIn152+		 (happy_var_1+	)}++happyReduce_360 = happyMonadReduce 3# 142# happyReduction_360+happyReduction_360 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut153 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftCurly) -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightCurly) -> +	( liftM (amap (const (ann happy_var_1 <++> nIS happy_var_3 <** [happy_var_2,happy_var_3]))) $ mkRecConstrOrUpdate happy_var_1 [])}}}+	) (\r -> happyReturn (happyIn153 r))++happyReduce_361 = happyMonadReduce 4# 142# happyReduction_361+happyReduction_361 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut153 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftCurly) -> +	case happyOut190 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (Loc happy_var_4 RightCurly) -> +	( liftM (amap (const (ann happy_var_1 <++> nIS happy_var_4 <** (happy_var_2:reverse (snd happy_var_3) ++ [happy_var_4]))))+                                              $ mkRecConstrOrUpdate happy_var_1 (reverse (fst happy_var_3)))}}}}+	) (\r -> happyReturn (happyIn153 r))++happyReduce_362 = happyReduce 4# 142# happyReduction_362+happyReduction_362 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut198 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftCurlyBar) -> +	case happyOut79 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (Loc happy_var_4 RightCurlyBar) -> +	happyIn153+		 (ExplTypeArg (ann happy_var_1 <++> nIS happy_var_4 <** [happy_var_2,happy_var_4]) happy_var_1 happy_var_3+	) `HappyStk` happyRest}}}}++happyReduce_363 = happySpecReduce_1  142# happyReduction_363+happyReduction_363 happy_x_1+	 =  case happyOut154 happy_x_1 of { happy_var_1 -> +	happyIn153+		 (happy_var_1+	)}++happyReduce_364 = happySpecReduce_1  143# happyReduction_364+happyReduction_364 happy_x_1+	 =  case happyOut199 happy_x_1 of { happy_var_1 -> +	happyIn154+		 (IPVar (ann happy_var_1) happy_var_1+	)}++happyReduce_365 = happySpecReduce_1  143# happyReduction_365+happyReduction_365 happy_x_1+	 =  case happyOut198 happy_x_1 of { happy_var_1 -> +	happyIn154+		 (Var (ann happy_var_1) happy_var_1+	)}++happyReduce_366 = happySpecReduce_1  143# happyReduction_366+happyReduction_366 happy_x_1+	 =  case happyOut195 happy_x_1 of { happy_var_1 -> +	happyIn154+		 (happy_var_1+	)}++happyReduce_367 = happySpecReduce_1  143# happyReduction_367+happyReduction_367 happy_x_1+	 =  case happyOut224 happy_x_1 of { happy_var_1 -> +	happyIn154+		 (Lit (ann happy_var_1) happy_var_1+	)}++happyReduce_368 = happySpecReduce_3  143# happyReduction_368+happyReduction_368 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> +	case happyOut156 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> +	happyIn154+		 (Paren (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3]) happy_var_2+	)}}}++happyReduce_369 = happySpecReduce_3  143# happyReduction_369+happyReduction_369 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> +	case happyOut156 happy_x_2 of { happy_var_2 -> +	case happyOut157 happy_x_3 of { happy_var_3 -> +	happyIn154+		 (TupleSection (happy_var_1 <^^> head (snd happy_var_3) <** happy_var_1:reverse (snd happy_var_3)) Boxed (Just happy_var_2 : fst happy_var_3)+	)}}}++happyReduce_370 = happyReduce 4# 143# happyReduction_370+happyReduction_370 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> +	case happyOut155 happy_x_2 of { happy_var_2 -> +	case happyOut156 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (Loc happy_var_4 RightParen) -> +	happyIn154+		 (TupleSection (happy_var_1 <^^> happy_var_4 <** happy_var_1:reverse (happy_var_4:happy_var_2)) Boxed+                                                      (replicate (length happy_var_2) Nothing ++ [Just happy_var_3])+	) `HappyStk` happyRest}}}}++happyReduce_371 = happyReduce 4# 143# happyReduction_371+happyReduction_371 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> +	case happyOut155 happy_x_2 of { happy_var_2 -> +	case happyOut156 happy_x_3 of { happy_var_3 -> +	case happyOut157 happy_x_4 of { happy_var_4 -> +	happyIn154+		 (TupleSection (happy_var_1 <^^> head (snd happy_var_4) <** happy_var_1:reverse (snd happy_var_4 ++ happy_var_2)) Boxed+                                                      (replicate (length happy_var_2) Nothing ++ Just happy_var_3 : fst happy_var_4)+	) `HappyStk` happyRest}}}}++happyReduce_372 = happySpecReduce_3  143# happyReduction_372+happyReduction_372 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftHashParen) -> +	case happyOut156 happy_x_2 of { happy_var_2 -> +	case happyOut158 happy_x_3 of { happy_var_3 -> +	happyIn154+		 (TupleSection (happy_var_1 <^^> head (snd happy_var_3) <** happy_var_1:reverse (snd happy_var_3)) Unboxed (Just happy_var_2 : fst happy_var_3)+	)}}}++happyReduce_373 = happySpecReduce_3  143# happyReduction_373+happyReduction_373 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftHashParen) -> +	case happyOut156 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightHashParen) -> +	happyIn154+		 (TupleSection (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3]) Unboxed [Just happy_var_2]+	)}}}++happyReduce_374 = happyReduce 4# 143# happyReduction_374+happyReduction_374 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftHashParen) -> +	case happyOut155 happy_x_2 of { happy_var_2 -> +	case happyOut156 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (Loc happy_var_4 RightHashParen) -> +	happyIn154+		 (TupleSection (happy_var_1 <^^> happy_var_4 <** happy_var_1:reverse (happy_var_4:happy_var_2)) Unboxed+                                                      (replicate (length happy_var_2) Nothing ++ [Just happy_var_3])+	) `HappyStk` happyRest}}}}++happyReduce_375 = happyReduce 4# 143# happyReduction_375+happyReduction_375 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftHashParen) -> +	case happyOut155 happy_x_2 of { happy_var_2 -> +	case happyOut156 happy_x_3 of { happy_var_3 -> +	case happyOut158 happy_x_4 of { happy_var_4 -> +	happyIn154+		 (TupleSection (happy_var_1 <^^> head (snd happy_var_4) <** happy_var_1:reverse (snd happy_var_4 ++ happy_var_2)) Unboxed+                                                      (replicate (length happy_var_2) Nothing ++ Just happy_var_3 : fst happy_var_4)+	) `HappyStk` happyRest}}}}++happyReduce_376 = happySpecReduce_3  143# happyReduction_376+happyReduction_376 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftSquare) -> +	case happyOut170 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightSquare) -> +	happyIn154+		 (amap (\l -> l <** [happy_var_3]) $ happy_var_2 (happy_var_1 <^^> happy_var_3 <** [happy_var_1])+	)}}}++happyReduce_377 = happySpecReduce_1  143# happyReduction_377+happyReduction_377 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Underscore) -> +	happyIn154+		 (WildCard (nIS happy_var_1)+	)}++happyReduce_378 = happyMonadReduce 3# 143# happyReduction_378+happyReduction_378 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> +	case happyOut160 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> +	( checkEnabled RegularPatterns >> return (Paren (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3]) happy_var_2))}}}+	) (\r -> happyReturn (happyIn154 r))++happyReduce_379 = happySpecReduce_3  143# happyReduction_379+happyReduction_379 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 RPGuardOpen) -> +	case happyOut159 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RPGuardClose) -> +	happyIn154+		 (SeqRP (happy_var_1 <^^> happy_var_3 <** (happy_var_1:reverse (snd happy_var_2) ++ [happy_var_3])) $ reverse (fst happy_var_2)+	)}}}++happyReduce_380 = happyReduce 5# 143# happyReduction_380+happyReduction_380 (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 { (Loc happy_var_1 RPGuardOpen) -> +	case happyOut140 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 Bar) -> +	case happyOut176 happy_x_4 of { happy_var_4 -> +	case happyOutTok happy_x_5 of { (Loc happy_var_5 RPGuardClose) -> +	happyIn154+		 (GuardRP (happy_var_1 <^^> happy_var_5 <** (happy_var_1:happy_var_3 : snd happy_var_4 ++ [happy_var_5])) happy_var_2 $ (reverse $ fst happy_var_4)+	) `HappyStk` happyRest}}}}}++happyReduce_381 = happySpecReduce_1  143# happyReduction_381+happyReduction_381 happy_x_1+	 =  case happyOut161 happy_x_1 of { happy_var_1 -> +	happyIn154+		 (happy_var_1+	)}++happyReduce_382 = happySpecReduce_1  143# happyReduction_382+happyReduction_382 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn154+		 (let Loc l (THIdEscape s) = happy_var_1 in SpliceExp (nIS l) $ IdSplice (nIS l) s+	)}++happyReduce_383 = happySpecReduce_3  143# happyReduction_383+happyReduction_383 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 THParenEscape) -> +	case happyOut139 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> +	happyIn154+		 (SpliceExp  (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3]) $ ParenSplice (ann happy_var_2) happy_var_2+	)}}}++happyReduce_384 = happySpecReduce_3  143# happyReduction_384+happyReduction_384 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 THExpQuote) -> +	case happyOut139 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 THCloseQuote) -> +	happyIn154+		 (BracketExp (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3]) $ ExpBracket  (ann happy_var_2) happy_var_2+	)}}}++happyReduce_385 = happyMonadReduce 3# 143# happyReduction_385+happyReduction_385 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 THPatQuote) -> +	case happyOut141 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 THCloseQuote) -> +	( do { p <- checkPattern happy_var_2;+                                              return $ BracketExp (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3]) $ PatBracket (ann p) p })}}}+	) (\r -> happyReturn (happyIn154 r))++happyReduce_386 = happySpecReduce_3  143# happyReduction_386+happyReduction_386 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 THTypQuote) -> +	case happyOut88 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 THCloseQuote) -> +	happyIn154+		 (let l = happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3] in BracketExp l $ TypeBracket l happy_var_2+	)}}}++happyReduce_387 = happyReduce 5# 143# happyReduction_387+happyReduction_387 (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 { (Loc happy_var_1 THDecQuote) -> +	case happyOut48 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_5 of { (Loc happy_var_5 THCloseQuote) -> +	happyIn154+		 (let l = happy_var_1 <^^> happy_var_5 <** (happy_var_1:snd happy_var_3 ++ [happy_var_5]) in BracketExp l $ DeclBracket l (fst happy_var_3)+	) `HappyStk` happyRest}}}++happyReduce_388 = happySpecReduce_2  143# happyReduction_388+happyReduction_388 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 THVarQuote) -> +	case happyOut198 happy_x_2 of { happy_var_2 -> +	happyIn154+		 (VarQuote (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2+	)}}++happyReduce_389 = happySpecReduce_2  143# happyReduction_389+happyReduction_389 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 THVarQuote) -> +	case happyOut201 happy_x_2 of { happy_var_2 -> +	happyIn154+		 (VarQuote (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2+	)}}++happyReduce_390 = happySpecReduce_2  143# happyReduction_390+happyReduction_390 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 THTyQuote) -> +	case happyOut230 happy_x_2 of { happy_var_2 -> +	happyIn154+		 (TypQuote (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) (UnQual (ann happy_var_2) happy_var_2)+	)}}++happyReduce_391 = happySpecReduce_2  143# happyReduction_391+happyReduction_391 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 THTyQuote) -> +	case happyOut85 happy_x_2 of { happy_var_2 -> +	happyIn154+		 (TypQuote (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2+	)}}++happyReduce_392 = happySpecReduce_1  143# happyReduction_392+happyReduction_392 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn154+		 (let Loc l (THQuasiQuote (n,q)) = happy_var_1 in QuasiQuote (nIS l) n q+	)}++happyReduce_393 = happySpecReduce_2  144# happyReduction_393+happyReduction_393 happy_x_2+	happy_x_1+	 =  case happyOut155 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> +	happyIn155+		 (happy_var_2 : happy_var_1+	)}}++happyReduce_394 = happySpecReduce_1  144# happyReduction_394+happyReduction_394 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Comma) -> +	happyIn155+		 ([happy_var_1]+	)}++happyReduce_395 = happySpecReduce_1  145# happyReduction_395+happyReduction_395 happy_x_1+	 =  case happyOut140 happy_x_1 of { happy_var_1 -> +	happyIn156+		 (happy_var_1+	)}++happyReduce_396 = happySpecReduce_2  145# happyReduction_396+happyReduction_396 happy_x_2+	happy_x_1+	 =  case happyOut209 happy_x_1 of { happy_var_1 -> +	case happyOut141 happy_x_2 of { happy_var_2 -> +	happyIn156+		 (PreOp (happy_var_1 <> happy_var_2) happy_var_1 happy_var_2+	)}}++happyReduce_397 = happyMonadReduce 3# 145# happyReduction_397+happyReduction_397 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut140 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 RightArrow) -> +	case happyOut140 happy_x_3 of { happy_var_3 -> +	( do {checkEnabled ViewPatterns;+                                             return $ ViewPat (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3})}}}+	) (\r -> happyReturn (happyIn156 r))++happyReduce_398 = happySpecReduce_3  146# happyReduction_398+happyReduction_398 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut155 happy_x_1 of { happy_var_1 -> +	case happyOut156 happy_x_2 of { happy_var_2 -> +	case happyOut157 happy_x_3 of { happy_var_3 -> +	happyIn157+		 (let (mes, ss) = happy_var_3 in (replicate (length happy_var_1 - 1) Nothing ++ Just happy_var_2 : mes, ss ++ happy_var_1)+	)}}}++happyReduce_399 = happySpecReduce_3  146# happyReduction_399+happyReduction_399 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut155 happy_x_1 of { happy_var_1 -> +	case happyOut156 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> +	happyIn157+		 ((replicate (length happy_var_1 - 1) Nothing ++ [Just happy_var_2], happy_var_3 : happy_var_1)+	)}}}++happyReduce_400 = happySpecReduce_2  146# happyReduction_400+happyReduction_400 happy_x_2+	happy_x_1+	 =  case happyOut155 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 RightParen) -> +	happyIn157+		 ((replicate (length happy_var_1) Nothing, happy_var_2 : happy_var_1)+	)}}++happyReduce_401 = happySpecReduce_3  147# happyReduction_401+happyReduction_401 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut155 happy_x_1 of { happy_var_1 -> +	case happyOut156 happy_x_2 of { happy_var_2 -> +	case happyOut158 happy_x_3 of { happy_var_3 -> +	happyIn158+		 (let (mes, ss) = happy_var_3 in (replicate (length happy_var_1 - 1) Nothing ++ Just happy_var_2 : mes, ss ++ happy_var_1)+	)}}}++happyReduce_402 = happySpecReduce_3  147# happyReduction_402+happyReduction_402 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut155 happy_x_1 of { happy_var_1 -> +	case happyOut156 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightHashParen) -> +	happyIn158+		 ((replicate (length happy_var_1 - 1) Nothing ++ [Just happy_var_2], happy_var_3 : happy_var_1)+	)}}}++happyReduce_403 = happySpecReduce_2  147# happyReduction_403+happyReduction_403 happy_x_2+	happy_x_1+	 =  case happyOut155 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 RightHashParen) -> +	happyIn158+		 ((replicate (length happy_var_1) Nothing, happy_var_2 : happy_var_1)+	)}}++happyReduce_404 = happySpecReduce_3  148# happyReduction_404+happyReduction_404 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut159 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> +	case happyOut140 happy_x_3 of { happy_var_3 -> +	happyIn159+		 ((happy_var_3 : fst happy_var_1, happy_var_2 : snd happy_var_1)+	)}}}++happyReduce_405 = happySpecReduce_1  148# happyReduction_405+happyReduction_405 happy_x_1+	 =  case happyOut140 happy_x_1 of { happy_var_1 -> +	happyIn159+		 (([happy_var_1],[])+	)}++happyReduce_406 = happySpecReduce_3  149# happyReduction_406+happyReduction_406 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut140 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 Bar) -> +	case happyOut160 happy_x_3 of { happy_var_3 -> +	happyIn160+		 (EitherRP (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3+	)}}}++happyReduce_407 = happySpecReduce_3  149# happyReduction_407+happyReduction_407 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut140 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 Bar) -> +	case happyOut140 happy_x_3 of { happy_var_3 -> +	happyIn160+		 (EitherRP (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3+	)}}}++happyReduce_408 = happyMonadReduce 10# 150# happyReduction_408+happyReduction_408 (happy_x_10 `HappyStk`+	happy_x_9 `HappyStk`+	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) tk+	 = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 XStdTagOpen) -> +	case happyOut164 happy_x_2 of { happy_var_2 -> +	case happyOut167 happy_x_3 of { happy_var_3 -> +	case happyOut169 happy_x_4 of { happy_var_4 -> +	case happyOutTok happy_x_5 of { (Loc happy_var_5 XStdTagClose) -> +	case happyOut162 happy_x_6 of { happy_var_6 -> +	case happyOut146 happy_x_7 of { happy_var_7 -> +	case happyOutTok happy_x_8 of { (Loc happy_var_8 XCloseTagOpen) -> +	case happyOut164 happy_x_9 of { happy_var_9 -> +	case happyOutTok happy_x_10 of { (Loc happy_var_10 XStdTagClose) -> +	( do { n <- checkEqNames happy_var_2 happy_var_9;+                                                                       let { cn = reverse happy_var_6;+                                                                             as = reverse happy_var_3;+                                                                             l  = happy_var_1 <^^> happy_var_10 <** [happy_var_1,happy_var_5] ++ happy_var_7 ++ [happy_var_8,srcInfoSpan (ann happy_var_9),happy_var_10] };+                                                                       return $ XTag l n as happy_var_4 cn })}}}}}}}}}}+	) (\r -> happyReturn (happyIn161 r))++happyReduce_409 = happyReduce 5# 150# happyReduction_409+happyReduction_409 (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 { (Loc happy_var_1 XStdTagOpen) -> +	case happyOut164 happy_x_2 of { happy_var_2 -> +	case happyOut167 happy_x_3 of { happy_var_3 -> +	case happyOut169 happy_x_4 of { happy_var_4 -> +	case happyOutTok happy_x_5 of { (Loc happy_var_5 XEmptyTagClose) -> +	happyIn161+		 (XETag   (happy_var_1 <^^> happy_var_5 <** [happy_var_1,happy_var_5]) happy_var_2 (reverse happy_var_3) happy_var_4+	) `HappyStk` happyRest}}}}}++happyReduce_410 = happySpecReduce_3  150# happyReduction_410+happyReduction_410 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 XCodeTagOpen) -> +	case happyOut140 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 XCodeTagClose) -> +	happyIn161+		 (XExpTag (happy_var_1 <^^> happy_var_3 <** [happy_var_1,happy_var_3]) happy_var_2+	)}}}++happyReduce_411 = happyReduce 5# 150# happyReduction_411+happyReduction_411 (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 { (Loc happy_var_1 XChildTagOpen) -> +	case happyOut162 happy_x_2 of { happy_var_2 -> +	case happyOut146 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (Loc happy_var_4 XCloseTagOpen) -> +	case happyOutTok happy_x_5 of { (Loc happy_var_5 XCodeTagClose) -> +	happyIn161+		 (XChildTag (happy_var_1 <^^> happy_var_5 <** (happy_var_1:happy_var_3++[happy_var_4,happy_var_5])) (reverse happy_var_2)+	) `HappyStk` happyRest}}}}}++happyReduce_412 = happySpecReduce_2  151# happyReduction_412+happyReduction_412 happy_x_2+	happy_x_1+	 =  case happyOut162 happy_x_1 of { happy_var_1 -> +	case happyOut163 happy_x_2 of { happy_var_2 -> +	happyIn162+		 (happy_var_2 : happy_var_1+	)}}++happyReduce_413 = happySpecReduce_0  151# happyReduction_413+happyReduction_413  =  happyIn162+		 ([]+	)++happyReduce_414 = happySpecReduce_1  152# happyReduction_414+happyReduction_414 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn163+		 (let Loc l (XPCDATA pcd) = happy_var_1 in XPcdata (nIS l) pcd+	)}++happyReduce_415 = happySpecReduce_3  152# happyReduction_415+happyReduction_415 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 XRPatOpen) -> +	case happyOut159 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 XRPatClose) -> +	happyIn163+		 (XRPats (happy_var_1 <^^> happy_var_3 <** (snd happy_var_2 ++ [happy_var_1,happy_var_3])) $ reverse (fst happy_var_2)+	)}}}++happyReduce_416 = happySpecReduce_1  152# happyReduction_416+happyReduction_416 happy_x_1+	 =  case happyOut161 happy_x_1 of { happy_var_1 -> +	happyIn163+		 (happy_var_1+	)}++happyReduce_417 = happySpecReduce_3  153# happyReduction_417+happyReduction_417 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut165 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 Colon) -> +	case happyOut165 happy_x_3 of { happy_var_3 -> +	happyIn164+		 (let {Loc l1 s1 = happy_var_1; Loc l2 s2 = happy_var_3}+                                         in XDomName (nIS l1 <++> nIS l2 <** [l1,happy_var_2,l2]) s1 s2+	)}}}++happyReduce_418 = happySpecReduce_1  153# happyReduction_418+happyReduction_418 happy_x_1+	 =  case happyOut165 happy_x_1 of { happy_var_1 -> +	happyIn164+		 (let Loc l str = happy_var_1 in XName (nIS l) str+	)}++happyReduce_419 = happySpecReduce_1  154# happyReduction_419+happyReduction_419 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn165+		 (let Loc l (VarId  s) = happy_var_1 in Loc l s+	)}++happyReduce_420 = happySpecReduce_1  154# happyReduction_420+happyReduction_420 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn165+		 (let Loc l (ConId  s) = happy_var_1 in Loc l s+	)}++happyReduce_421 = happySpecReduce_1  154# happyReduction_421+happyReduction_421 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn165+		 (let Loc l (DVarId s) = happy_var_1 in Loc l $ mkDVar s+	)}++happyReduce_422 = happySpecReduce_1  154# happyReduction_422+happyReduction_422 happy_x_1+	 =  case happyOut166 happy_x_1 of { happy_var_1 -> +	happyIn165+		 (happy_var_1+	)}++happyReduce_423 = happySpecReduce_1  155# happyReduction_423+happyReduction_423 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Type) -> +	happyIn166+		 (Loc happy_var_1 "type"+	)}++happyReduce_424 = happySpecReduce_1  155# happyReduction_424+happyReduction_424 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Class) -> +	happyIn166+		 (Loc happy_var_1 "class"+	)}++happyReduce_425 = happySpecReduce_1  155# happyReduction_425+happyReduction_425 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Data) -> +	happyIn166+		 (Loc happy_var_1 "data"+	)}++happyReduce_426 = happySpecReduce_1  155# happyReduction_426+happyReduction_426 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Foreign) -> +	happyIn166+		 (Loc happy_var_1 "foreign"+	)}++happyReduce_427 = happySpecReduce_1  155# happyReduction_427+happyReduction_427 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Export) -> +	happyIn166+		 (Loc happy_var_1 "export"+	)}++happyReduce_428 = happySpecReduce_1  155# happyReduction_428+happyReduction_428 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Safe) -> +	happyIn166+		 (Loc happy_var_1 "safe"+	)}++happyReduce_429 = happySpecReduce_1  155# happyReduction_429+happyReduction_429 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Unsafe) -> +	happyIn166+		 (Loc happy_var_1 "unsafe"+	)}++happyReduce_430 = happySpecReduce_1  155# happyReduction_430+happyReduction_430 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Threadsafe) -> +	happyIn166+		 (Loc happy_var_1 "threadsafe"+	)}++happyReduce_431 = happySpecReduce_1  155# happyReduction_431+happyReduction_431 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_StdCall) -> +	happyIn166+		 (Loc happy_var_1 "stdcall"+	)}++happyReduce_432 = happySpecReduce_1  155# happyReduction_432+happyReduction_432 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_CCall) -> +	happyIn166+		 (Loc happy_var_1 "ccall"+	)}++happyReduce_433 = happySpecReduce_1  155# happyReduction_433+happyReduction_433 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_CPlusPlus) -> +	happyIn166+		 (Loc happy_var_1 "cplusplus"+	)}++happyReduce_434 = happySpecReduce_1  155# happyReduction_434+happyReduction_434 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_DotNet) -> +	happyIn166+		 (Loc happy_var_1 "dotnet"+	)}++happyReduce_435 = happySpecReduce_1  155# happyReduction_435+happyReduction_435 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Jvm) -> +	happyIn166+		 (Loc happy_var_1 "jvm"+	)}++happyReduce_436 = happySpecReduce_1  155# happyReduction_436+happyReduction_436 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Js) -> +	happyIn166+		 (Loc happy_var_1 "js"+	)}++happyReduce_437 = happySpecReduce_1  155# happyReduction_437+happyReduction_437 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_As) -> +	happyIn166+		 (Loc happy_var_1 "as"+	)}++happyReduce_438 = happySpecReduce_1  155# happyReduction_438+happyReduction_438 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_By) -> +	happyIn166+		 (Loc happy_var_1 "by"+	)}++happyReduce_439 = happySpecReduce_1  155# happyReduction_439+happyReduction_439 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Case) -> +	happyIn166+		 (Loc happy_var_1 "case"+	)}++happyReduce_440 = happySpecReduce_1  155# happyReduction_440+happyReduction_440 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Default) -> +	happyIn166+		 (Loc happy_var_1 "default"+	)}++happyReduce_441 = happySpecReduce_1  155# happyReduction_441+happyReduction_441 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Deriving) -> +	happyIn166+		 (Loc happy_var_1 "deriving"+	)}++happyReduce_442 = happySpecReduce_1  155# happyReduction_442+happyReduction_442 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Do) -> +	happyIn166+		 (Loc happy_var_1 "do"+	)}++happyReduce_443 = happySpecReduce_1  155# happyReduction_443+happyReduction_443 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Else) -> +	happyIn166+		 (Loc happy_var_1 "else"+	)}++happyReduce_444 = happySpecReduce_1  155# happyReduction_444+happyReduction_444 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Family) -> +	happyIn166+		 (Loc happy_var_1 "family"+	)}++happyReduce_445 = happySpecReduce_1  155# happyReduction_445+happyReduction_445 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Forall) -> +	happyIn166+		 (Loc happy_var_1 "forall"+	)}++happyReduce_446 = happySpecReduce_1  155# happyReduction_446+happyReduction_446 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Group) -> +	happyIn166+		 (Loc happy_var_1 "group"+	)}++happyReduce_447 = happySpecReduce_1  155# happyReduction_447+happyReduction_447 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Hiding) -> +	happyIn166+		 (Loc happy_var_1 "hiding"+	)}++happyReduce_448 = happySpecReduce_1  155# happyReduction_448+happyReduction_448 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_If) -> +	happyIn166+		 (Loc happy_var_1 "if"+	)}++happyReduce_449 = happySpecReduce_1  155# happyReduction_449+happyReduction_449 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Import) -> +	happyIn166+		 (Loc happy_var_1 "import"+	)}++happyReduce_450 = happySpecReduce_1  155# happyReduction_450+happyReduction_450 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_In) -> +	happyIn166+		 (Loc happy_var_1 "in"+	)}++happyReduce_451 = happySpecReduce_1  155# happyReduction_451+happyReduction_451 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Infix) -> +	happyIn166+		 (Loc happy_var_1 "infix"+	)}++happyReduce_452 = happySpecReduce_1  155# happyReduction_452+happyReduction_452 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_InfixL) -> +	happyIn166+		 (Loc happy_var_1 "infixl"+	)}++happyReduce_453 = happySpecReduce_1  155# happyReduction_453+happyReduction_453 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_InfixR) -> +	happyIn166+		 (Loc happy_var_1 "infixr"+	)}++happyReduce_454 = happySpecReduce_1  155# happyReduction_454+happyReduction_454 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Instance) -> +	happyIn166+		 (Loc happy_var_1 "instance"+	)}++happyReduce_455 = happySpecReduce_1  155# happyReduction_455+happyReduction_455 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Let) -> +	happyIn166+		 (Loc happy_var_1 "let"+	)}++happyReduce_456 = happySpecReduce_1  155# happyReduction_456+happyReduction_456 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_MDo) -> +	happyIn166+		 (Loc happy_var_1 "mdo"+	)}++happyReduce_457 = happySpecReduce_1  155# happyReduction_457+happyReduction_457 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Module) -> +	happyIn166+		 (Loc happy_var_1 "module"+	)}++happyReduce_458 = happySpecReduce_1  155# happyReduction_458+happyReduction_458 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_NewType) -> +	happyIn166+		 (Loc happy_var_1 "newtype"+	)}++happyReduce_459 = happySpecReduce_1  155# happyReduction_459+happyReduction_459 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Of) -> +	happyIn166+		 (Loc happy_var_1 "of"+	)}++happyReduce_460 = happySpecReduce_1  155# happyReduction_460+happyReduction_460 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Proc) -> +	happyIn166+		 (Loc happy_var_1 "proc"+	)}++happyReduce_461 = happySpecReduce_1  155# happyReduction_461+happyReduction_461 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Rec) -> +	happyIn166+		 (Loc happy_var_1 "rec"+	)}++happyReduce_462 = happySpecReduce_1  155# happyReduction_462+happyReduction_462 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Then) -> +	happyIn166+		 (Loc happy_var_1 "then"+	)}++happyReduce_463 = happySpecReduce_1  155# happyReduction_463+happyReduction_463 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Using) -> +	happyIn166+		 (Loc happy_var_1 "using"+	)}++happyReduce_464 = happySpecReduce_1  155# happyReduction_464+happyReduction_464 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Where) -> +	happyIn166+		 (Loc happy_var_1 "where"+	)}++happyReduce_465 = happySpecReduce_1  155# happyReduction_465+happyReduction_465 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Qualified) -> +	happyIn166+		 (Loc happy_var_1 "qualified"+	)}++happyReduce_466 = happySpecReduce_2  156# happyReduction_466+happyReduction_466 happy_x_2+	happy_x_1+	 =  case happyOut167 happy_x_1 of { happy_var_1 -> +	case happyOut168 happy_x_2 of { happy_var_2 -> +	happyIn167+		 (happy_var_2 : happy_var_1+	)}}++happyReduce_467 = happySpecReduce_0  156# happyReduction_467+happyReduction_467  =  happyIn167+		 ([]+	)++happyReduce_468 = happySpecReduce_3  157# happyReduction_468+happyReduction_468 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut164 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 Equals) -> +	case happyOut152 happy_x_3 of { happy_var_3 -> +	happyIn168+		 (XAttr (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3+	)}}}++happyReduce_469 = happySpecReduce_1  158# happyReduction_469+happyReduction_469 happy_x_1+	 =  case happyOut152 happy_x_1 of { happy_var_1 -> +	happyIn169+		 (Just happy_var_1+	)}++happyReduce_470 = happySpecReduce_0  158# happyReduction_470+happyReduction_470  =  happyIn169+		 (Nothing+	)++happyReduce_471 = happySpecReduce_1  159# happyReduction_471+happyReduction_471 happy_x_1+	 =  case happyOut156 happy_x_1 of { happy_var_1 -> +	happyIn170+		 (\l -> List l [happy_var_1]+	)}++happyReduce_472 = happySpecReduce_1  159# happyReduction_472+happyReduction_472 happy_x_1+	 =  case happyOut171 happy_x_1 of { happy_var_1 -> +	happyIn170+		 (\l -> let (ps,ss) = happy_var_1 in List (l <** reverse ss) (reverse ps)+	)}++happyReduce_473 = happySpecReduce_2  159# happyReduction_473+happyReduction_473 happy_x_2+	happy_x_1+	 =  case happyOut156 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 DotDot) -> +	happyIn170+		 (\l -> EnumFrom       (l <** [happy_var_2]) happy_var_1+	)}}++happyReduce_474 = happyReduce 4# 159# happyReduction_474+happyReduction_474 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut156 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> +	case happyOut140 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (Loc happy_var_4 DotDot) -> +	happyIn170+		 (\l -> EnumFromThen   (l <** [happy_var_2,happy_var_4]) happy_var_1 happy_var_3+	) `HappyStk` happyRest}}}}++happyReduce_475 = happySpecReduce_3  159# happyReduction_475+happyReduction_475 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut156 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 DotDot) -> +	case happyOut140 happy_x_3 of { happy_var_3 -> +	happyIn170+		 (\l -> EnumFromTo     (l <** [happy_var_2]) happy_var_1 happy_var_3+	)}}}++happyReduce_476 = happyReduce 5# 159# happyReduction_476+happyReduction_476 (happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut156 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> +	case happyOut140 happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { (Loc happy_var_4 DotDot) -> +	case happyOut140 happy_x_5 of { happy_var_5 -> +	happyIn170+		 (\l -> EnumFromThenTo (l <** [happy_var_2,happy_var_4]) happy_var_1 happy_var_3 happy_var_5+	) `HappyStk` happyRest}}}}}++happyReduce_477 = happySpecReduce_3  159# happyReduction_477+happyReduction_477 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut156 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 Bar) -> +	case happyOut172 happy_x_3 of { happy_var_3 -> +	happyIn170+		 (\l -> let (stss, ss) = happy_var_3 in ParComp (l <** (happy_var_2:ss)) happy_var_1 (reverse stss)+	)}}}++happyReduce_478 = happySpecReduce_3  160# happyReduction_478+happyReduction_478 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut171 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> +	case happyOut156 happy_x_3 of { happy_var_3 -> +	happyIn171+		 (let (es, ss) = happy_var_1 in (happy_var_3 : es, happy_var_2 : ss)+	)}}}++happyReduce_479 = happySpecReduce_3  160# happyReduction_479+happyReduction_479 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut156 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> +	case happyOut156 happy_x_3 of { happy_var_3 -> +	happyIn171+		 (([happy_var_3,happy_var_1], [happy_var_2])+	)}}}++happyReduce_480 = happySpecReduce_3  161# happyReduction_480+happyReduction_480 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut172 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 Bar) -> +	case happyOut173 happy_x_3 of { happy_var_3 -> +	happyIn172+		 (let { (stss, ss1) = happy_var_1;+                                              (sts, ss2) = happy_var_3 }+                                         in (reverse sts : stss, ss1 ++ [happy_var_2] ++ reverse ss2)+	)}}}++happyReduce_481 = happySpecReduce_1  161# happyReduction_481+happyReduction_481 happy_x_1+	 =  case happyOut173 happy_x_1 of { happy_var_1 -> +	happyIn172+		 (let (sts, ss) = happy_var_1 in ([reverse sts], reverse ss)+	)}++happyReduce_482 = happySpecReduce_3  162# happyReduction_482+happyReduction_482 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut173 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> +	case happyOut174 happy_x_3 of { happy_var_3 -> +	happyIn173+		 (let (sts, ss) = happy_var_1 in (happy_var_3 : sts, happy_var_2 : ss)+	)}}}++happyReduce_483 = happySpecReduce_1  162# happyReduction_483+happyReduction_483 happy_x_1+	 =  case happyOut174 happy_x_1 of { happy_var_1 -> +	happyIn173+		 (([happy_var_1],[])+	)}++happyReduce_484 = happySpecReduce_1  163# happyReduction_484+happyReduction_484 happy_x_1+	 =  case happyOut175 happy_x_1 of { happy_var_1 -> +	happyIn174+		 (happy_var_1+	)}++happyReduce_485 = happySpecReduce_1  163# happyReduction_485+happyReduction_485 happy_x_1+	 =  case happyOut177 happy_x_1 of { happy_var_1 -> +	happyIn174+		 (QualStmt (ann happy_var_1) happy_var_1+	)}++happyReduce_486 = happySpecReduce_2  164# happyReduction_486+happyReduction_486 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Then) -> +	case happyOut139 happy_x_2 of { happy_var_2 -> +	happyIn175+		 (ThenTrans    (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2+	)}}++happyReduce_487 = happyReduce 4# 164# happyReduction_487+happyReduction_487 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Then) -> +	case happyOut139 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 KW_By) -> +	case happyOut139 happy_x_4 of { happy_var_4 -> +	happyIn175+		 (ThenBy       (nIS happy_var_1 <++> ann happy_var_4 <** [happy_var_1,happy_var_3]) happy_var_2 happy_var_4+	) `HappyStk` happyRest}}}}++happyReduce_488 = happyReduce 4# 164# happyReduction_488+happyReduction_488 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Then) -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 KW_Group) -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 KW_By) -> +	case happyOut139 happy_x_4 of { happy_var_4 -> +	happyIn175+		 (GroupBy      (nIS happy_var_1 <++> ann happy_var_4 <** [happy_var_1,happy_var_2,happy_var_3]) happy_var_4+	) `HappyStk` happyRest}}}}++happyReduce_489 = happyReduce 4# 164# happyReduction_489+happyReduction_489 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Then) -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 KW_Group) -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 KW_Using) -> +	case happyOut139 happy_x_4 of { happy_var_4 -> +	happyIn175+		 (GroupUsing   (nIS happy_var_1 <++> ann happy_var_4 <** [happy_var_1,happy_var_2,happy_var_3]) happy_var_4+	) `HappyStk` happyRest}}}}++happyReduce_490 = happyReduce 6# 164# happyReduction_490+happyReduction_490 (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 { (Loc happy_var_1 KW_Then) -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 KW_Group) -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 KW_By) -> +	case happyOut139 happy_x_4 of { happy_var_4 -> +	case happyOutTok happy_x_5 of { (Loc happy_var_5 KW_Using) -> +	case happyOut139 happy_x_6 of { happy_var_6 -> +	happyIn175+		 (GroupByUsing (nIS happy_var_1 <++> ann happy_var_6 <** [happy_var_1,happy_var_2,happy_var_3,happy_var_5]) happy_var_4 happy_var_6+	) `HappyStk` happyRest}}}}}}++happyReduce_491 = happySpecReduce_3  165# happyReduction_491+happyReduction_491 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut176 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> +	case happyOut177 happy_x_3 of { happy_var_3 -> +	happyIn176+		 (let (sts, ss) = happy_var_1 in (happy_var_3 : sts, happy_var_2 : ss)+	)}}}++happyReduce_492 = happySpecReduce_1  165# happyReduction_492+happyReduction_492 happy_x_1+	 =  case happyOut177 happy_x_1 of { happy_var_1 -> +	happyIn176+		 (([happy_var_1],[])+	)}++happyReduce_493 = happySpecReduce_3  166# happyReduction_493+happyReduction_493 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut185 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftArrow) -> +	case happyOut139 happy_x_3 of { happy_var_3 -> +	happyIn177+		 (Generator (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3+	)}}}++happyReduce_494 = happySpecReduce_1  166# happyReduction_494+happyReduction_494 happy_x_1+	 =  case happyOut139 happy_x_1 of { happy_var_1 -> +	happyIn177+		 (Qualifier (ann happy_var_1) happy_var_1+	)}++happyReduce_495 = happySpecReduce_2  166# happyReduction_495+happyReduction_495 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Let) -> +	case happyOut61 happy_x_2 of { happy_var_2 -> +	happyIn177+		 (LetStmt   (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2+	)}}++happyReduce_496 = happySpecReduce_3  167# happyReduction_496+happyReduction_496 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftCurly) -> +	case happyOut179 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightCurly) -> +	happyIn178+		 ((fst happy_var_2, happy_var_1 <^^> happy_var_3, happy_var_1:snd happy_var_2 ++ [happy_var_3])+	)}}}++happyReduce_497 = happySpecReduce_3  167# happyReduction_497+happyReduction_497 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut225 happy_x_1 of { happy_var_1 -> +	case happyOut179 happy_x_2 of { happy_var_2 -> +	case happyOut226 happy_x_3 of { happy_var_3 -> +	happyIn178+		 ((fst happy_var_2, happy_var_1 <^^> happy_var_3, happy_var_1:snd happy_var_2 ++ [happy_var_3])+	)}}}++happyReduce_498 = happySpecReduce_3  168# happyReduction_498+happyReduction_498 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut25 happy_x_1 of { happy_var_1 -> +	case happyOut180 happy_x_2 of { happy_var_2 -> +	case happyOut25 happy_x_3 of { happy_var_3 -> +	happyIn179+		 ((reverse $ fst happy_var_2, happy_var_1 ++ snd happy_var_2 ++ happy_var_3)+	)}}}++happyReduce_499 = happySpecReduce_3  169# happyReduction_499+happyReduction_499 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut180 happy_x_1 of { happy_var_1 -> +	case happyOut24 happy_x_2 of { happy_var_2 -> +	case happyOut181 happy_x_3 of { happy_var_3 -> +	happyIn180+		 ((happy_var_3 : fst happy_var_1, snd happy_var_1 ++ happy_var_2)+	)}}}++happyReduce_500 = happySpecReduce_1  169# happyReduction_500+happyReduction_500 happy_x_1+	 =  case happyOut181 happy_x_1 of { happy_var_1 -> +	happyIn180+		 (([happy_var_1],[])+	)}++happyReduce_501 = happySpecReduce_3  170# happyReduction_501+happyReduction_501 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut185 happy_x_1 of { happy_var_1 -> +	case happyOut182 happy_x_2 of { happy_var_2 -> +	case happyOut134 happy_x_3 of { happy_var_3 -> +	happyIn181+		 (Alt (happy_var_1 <> happy_var_2 <+?> (fmap ann) (fst happy_var_3) <** snd happy_var_3) happy_var_1 happy_var_2 (fst happy_var_3)+	)}}}++happyReduce_502 = happySpecReduce_2  171# happyReduction_502+happyReduction_502 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 RightArrow) -> +	case happyOut139 happy_x_2 of { happy_var_2 -> +	happyIn182+		 (UnGuardedAlt (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2+	)}}++happyReduce_503 = happySpecReduce_1  171# happyReduction_503+happyReduction_503 happy_x_1+	 =  case happyOut183 happy_x_1 of { happy_var_1 -> +	happyIn182+		 (GuardedAlts  (snd happy_var_1) (reverse $ fst happy_var_1)+	)}++happyReduce_504 = happySpecReduce_2  172# happyReduction_504+happyReduction_504 happy_x_2+	happy_x_1+	 =  case happyOut183 happy_x_1 of { happy_var_1 -> +	case happyOut184 happy_x_2 of { happy_var_2 -> +	happyIn183+		 ((happy_var_2 : fst happy_var_1, snd happy_var_1 <++> ann happy_var_2)+	)}}++happyReduce_505 = happySpecReduce_1  172# happyReduction_505+happyReduction_505 happy_x_1+	 =  case happyOut184 happy_x_1 of { happy_var_1 -> +	happyIn183+		 (([happy_var_1], ann happy_var_1)+	)}++happyReduce_506 = happyMonadReduce 4# 173# happyReduction_506+happyReduction_506 (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 { (Loc happy_var_1 Bar) -> +	case happyOut176 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightArrow) -> +	case happyOut139 happy_x_4 of { happy_var_4 -> +	( do { checkPatternGuards (fst happy_var_2);+                                       let {l = nIS happy_var_1 <++> ann happy_var_4 <** (happy_var_1:snd happy_var_2 ++ [happy_var_3])};+                                       return (GuardedAlt l (reverse (fst happy_var_2)) happy_var_4) })}}}}+	) (\r -> happyReturn (happyIn184 r))++happyReduce_507 = happyMonadReduce 1# 174# happyReduction_507+happyReduction_507 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut140 happy_x_1 of { happy_var_1 -> +	( checkPattern happy_var_1)}+	) (\r -> happyReturn (happyIn185 r))++happyReduce_508 = happyMonadReduce 2# 174# happyReduction_508+happyReduction_508 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 Exclamation) -> +	case happyOut152 happy_x_2 of { happy_var_2 -> +	( checkPattern (BangPat (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2))}}+	) (\r -> happyReturn (happyIn185 r))++happyReduce_509 = happySpecReduce_3  175# happyReduction_509+happyReduction_509 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftCurly) -> +	case happyOut187 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightCurly) -> +	happyIn186+		 ((fst happy_var_2, happy_var_1 <^^> happy_var_3, happy_var_1:snd happy_var_2 ++ [happy_var_3])+	)}}}++happyReduce_510 = happySpecReduce_3  175# happyReduction_510+happyReduction_510 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut225 happy_x_1 of { happy_var_1 -> +	case happyOut187 happy_x_2 of { happy_var_2 -> +	case happyOut226 happy_x_3 of { happy_var_3 -> +	happyIn186+		 ((fst happy_var_2, happy_var_1 <^^> happy_var_3, happy_var_1:snd happy_var_2 ++ [happy_var_3])+	)}}}++happyReduce_511 = happySpecReduce_2  176# happyReduction_511+happyReduction_511 happy_x_2+	happy_x_1+	 =  case happyOut189 happy_x_1 of { happy_var_1 -> +	case happyOut188 happy_x_2 of { happy_var_2 -> +	happyIn187+		 ((happy_var_1 : fst happy_var_2, snd happy_var_2)+	)}}++happyReduce_512 = happySpecReduce_2  176# happyReduction_512+happyReduction_512 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 SemiColon) -> +	case happyOut187 happy_x_2 of { happy_var_2 -> +	happyIn187+		 ((fst happy_var_2, happy_var_1 : snd happy_var_2)+	)}}++happyReduce_513 = happySpecReduce_0  176# happyReduction_513+happyReduction_513  =  happyIn187+		 (([],[])+	)++happyReduce_514 = happySpecReduce_2  177# happyReduction_514+happyReduction_514 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 SemiColon) -> +	case happyOut187 happy_x_2 of { happy_var_2 -> +	happyIn188+		 ((fst happy_var_2, happy_var_1 : snd happy_var_2)+	)}}++happyReduce_515 = happySpecReduce_0  177# happyReduction_515+happyReduction_515  =  happyIn188+		 (([],[])+	)++happyReduce_516 = happySpecReduce_2  178# happyReduction_516+happyReduction_516 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Let) -> +	case happyOut61 happy_x_2 of { happy_var_2 -> +	happyIn189+		 (LetStmt (nIS happy_var_1 <++> ann happy_var_2 <** [happy_var_1]) happy_var_2+	)}}++happyReduce_517 = happySpecReduce_3  178# happyReduction_517+happyReduction_517 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut185 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 LeftArrow) -> +	case happyOut139 happy_x_3 of { happy_var_3 -> +	happyIn189+		 (Generator (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3+	)}}}++happyReduce_518 = happySpecReduce_1  178# happyReduction_518+happyReduction_518 happy_x_1+	 =  case happyOut139 happy_x_1 of { happy_var_1 -> +	happyIn189+		 (Qualifier (ann happy_var_1) happy_var_1+	)}++happyReduce_519 = happySpecReduce_2  178# happyReduction_519+happyReduction_519 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Rec) -> +	case happyOut186 happy_x_2 of { happy_var_2 -> +	happyIn189+		 (let (stms,inf,ss) = happy_var_2 in RecStmt (nIS happy_var_1 <++> inf <** happy_var_1:ss) stms+	)}}++happyReduce_520 = happySpecReduce_3  179# happyReduction_520+happyReduction_520 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut190 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 Comma) -> +	case happyOut191 happy_x_3 of { happy_var_3 -> +	happyIn190+		 (let (fbs, ss) = happy_var_1 in (happy_var_3 : fbs, happy_var_2 : ss)+	)}}}++happyReduce_521 = happySpecReduce_1  179# happyReduction_521+happyReduction_521 happy_x_1+	 =  case happyOut191 happy_x_1 of { happy_var_1 -> +	happyIn190+		 (([happy_var_1],[])+	)}++happyReduce_522 = happySpecReduce_3  180# happyReduction_522+happyReduction_522 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut198 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 Equals) -> +	case happyOut140 happy_x_3 of { happy_var_3 -> +	happyIn191+		 (FieldUpdate (happy_var_1 <>happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3+	)}}}++happyReduce_523 = happyMonadReduce 1# 180# happyReduction_523+happyReduction_523 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOut198 happy_x_1 of { happy_var_1 -> +	( checkEnabled NamedFieldPuns >> checkUnQual happy_var_1 >>= return . FieldPun (ann happy_var_1))}+	) (\r -> happyReturn (happyIn191 r))++happyReduce_524 = happyMonadReduce 1# 180# happyReduction_524+happyReduction_524 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (case happyOutTok happy_x_1 of { (Loc happy_var_1 DotDot) -> +	( checkEnabled RecordWildCards >> return (FieldWildcard (nIS happy_var_1)))}+	) (\r -> happyReturn (happyIn191 r))++happyReduce_525 = happySpecReduce_3  181# happyReduction_525+happyReduction_525 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut25 happy_x_1 of { happy_var_1 -> +	case happyOut193 happy_x_2 of { happy_var_2 -> +	case happyOut25 happy_x_3 of { happy_var_3 -> +	happyIn192+		 ((reverse (fst happy_var_2), reverse happy_var_1 ++ snd happy_var_2 ++ reverse happy_var_3)+	)}}}++happyReduce_526 = happySpecReduce_3  182# happyReduction_526+happyReduction_526 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut193 happy_x_1 of { happy_var_1 -> +	case happyOut24 happy_x_2 of { happy_var_2 -> +	case happyOut194 happy_x_3 of { happy_var_3 -> +	happyIn193+		 ((happy_var_3 : fst happy_var_1, snd happy_var_1 ++ reverse happy_var_2)+	)}}}++happyReduce_527 = happySpecReduce_1  182# happyReduction_527+happyReduction_527 happy_x_1+	 =  case happyOut194 happy_x_1 of { happy_var_1 -> +	happyIn193+		 (([happy_var_1],[])+	)}++happyReduce_528 = happySpecReduce_3  183# happyReduction_528+happyReduction_528 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut199 happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 Equals) -> +	case happyOut139 happy_x_3 of { happy_var_3 -> +	happyIn194+		 (IPBind (happy_var_1 <> happy_var_3 <** [happy_var_2]) happy_var_1 happy_var_3+	)}}}++happyReduce_529 = happySpecReduce_2  184# happyReduction_529+happyReduction_529 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 RightParen) -> +	happyIn195+		 (p_unit_con              (happy_var_1 <^^> happy_var_2 <** [happy_var_1,happy_var_2])+	)}}++happyReduce_530 = happySpecReduce_2  184# happyReduction_530+happyReduction_530 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftSquare) -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 RightSquare) -> +	happyIn195+		 (List                    (happy_var_1 <^^> happy_var_2 <** [happy_var_1,happy_var_2]) []+	)}}++happyReduce_531 = happySpecReduce_3  184# happyReduction_531+happyReduction_531 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> +	case happyOut155 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> +	happyIn195+		 (p_tuple_con             (happy_var_1 <^^> happy_var_3 <** happy_var_1:reverse (happy_var_3:happy_var_2)) Boxed (length happy_var_2)+	)}}}++happyReduce_532 = happySpecReduce_2  184# happyReduction_532+happyReduction_532 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftHashParen) -> +	case happyOutTok happy_x_2 of { (Loc happy_var_2 RightHashParen) -> +	happyIn195+		 (p_unboxed_singleton_con (happy_var_1 <^^> happy_var_2 <** [happy_var_1,happy_var_2])+	)}}++happyReduce_533 = happySpecReduce_3  184# happyReduction_533+happyReduction_533 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftHashParen) -> +	case happyOut155 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightHashParen) -> +	happyIn195+		 (p_tuple_con             (happy_var_1 <^^> happy_var_3 <** happy_var_1:reverse (happy_var_3:happy_var_2)) Unboxed (length happy_var_2)+	)}}}++happyReduce_534 = happySpecReduce_1  184# happyReduction_534+happyReduction_534 happy_x_1+	 =  case happyOut201 happy_x_1 of { happy_var_1 -> +	happyIn195+		 (Con (ann happy_var_1) happy_var_1+	)}++happyReduce_535 = happySpecReduce_1  185# happyReduction_535+happyReduction_535 happy_x_1+	 =  case happyOut213 happy_x_1 of { happy_var_1 -> +	happyIn196+		 (happy_var_1+	)}++happyReduce_536 = happySpecReduce_3  185# happyReduction_536+happyReduction_536 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> +	case happyOut221 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> +	happyIn196+		 (fmap (const (happy_var_1 <^^> happy_var_3 <** [happy_var_1, srcInfoSpan (ann happy_var_2), happy_var_3])) happy_var_2+	)}}}++happyReduce_537 = happySpecReduce_1  186# happyReduction_537+happyReduction_537 happy_x_1+	 =  case happyOut212 happy_x_1 of { happy_var_1 -> +	happyIn197+		 (happy_var_1+	)}++happyReduce_538 = happySpecReduce_3  186# happyReduction_538+happyReduction_538 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> +	case happyOut221 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> +	happyIn197+		 (fmap (const (happy_var_1 <^^> happy_var_3 <** [happy_var_1, srcInfoSpan (ann happy_var_2), happy_var_3])) happy_var_2+	)}}}++happyReduce_539 = happySpecReduce_1  187# happyReduction_539+happyReduction_539 happy_x_1+	 =  case happyOut211 happy_x_1 of { happy_var_1 -> +	happyIn198+		 (happy_var_1+	)}++happyReduce_540 = happySpecReduce_3  187# happyReduction_540+happyReduction_540 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> +	case happyOut219 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> +	happyIn198+		 (fmap (const (happy_var_1 <^^> happy_var_3 <** [happy_var_1, srcInfoSpan (ann happy_var_2), happy_var_3])) happy_var_2+	)}}}++happyReduce_541 = happySpecReduce_1  188# happyReduction_541+happyReduction_541 happy_x_1+	 =  case happyOut214 happy_x_1 of { happy_var_1 -> +	happyIn199+		 (happy_var_1+	)}++happyReduce_542 = happySpecReduce_1  189# happyReduction_542+happyReduction_542 happy_x_1+	 =  case happyOut216 happy_x_1 of { happy_var_1 -> +	happyIn200+		 (happy_var_1+	)}++happyReduce_543 = happySpecReduce_3  189# happyReduction_543+happyReduction_543 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> +	case happyOut218 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> +	happyIn200+		 (fmap (const (happy_var_1 <^^> happy_var_3 <** [happy_var_1, srcInfoSpan (ann happy_var_2), happy_var_3])) happy_var_2+	)}}}++happyReduce_544 = happySpecReduce_1  190# happyReduction_544+happyReduction_544 happy_x_1+	 =  case happyOut215 happy_x_1 of { happy_var_1 -> +	happyIn201+		 (happy_var_1+	)}++happyReduce_545 = happySpecReduce_3  190# happyReduction_545+happyReduction_545 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 LeftParen) -> +	case happyOut210 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 RightParen) -> +	happyIn201+		 (fmap (const (happy_var_1 <^^> happy_var_3 <** [happy_var_1, srcInfoSpan (ann happy_var_2), happy_var_3])) happy_var_2+	)}}}++happyReduce_546 = happySpecReduce_1  191# happyReduction_546+happyReduction_546 happy_x_1+	 =  case happyOut221 happy_x_1 of { happy_var_1 -> +	happyIn202+		 (happy_var_1+	)}++happyReduce_547 = happySpecReduce_3  191# happyReduction_547+happyReduction_547 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 BackQuote) -> +	case happyOut213 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 BackQuote) -> +	happyIn202+		 (fmap (const (happy_var_1 <^^> happy_var_3 <** [happy_var_1, srcInfoSpan (ann happy_var_2), happy_var_3])) happy_var_2+	)}}}++happyReduce_548 = happySpecReduce_1  192# happyReduction_548+happyReduction_548 happy_x_1+	 =  case happyOut219 happy_x_1 of { happy_var_1 -> +	happyIn203+		 (happy_var_1+	)}++happyReduce_549 = happySpecReduce_3  192# happyReduction_549+happyReduction_549 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 BackQuote) -> +	case happyOut211 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 BackQuote) -> +	happyIn203+		 (fmap (const (happy_var_1 <^^> happy_var_3 <** [happy_var_1, srcInfoSpan (ann happy_var_2), happy_var_3])) happy_var_2+	)}}}++happyReduce_550 = happySpecReduce_1  193# happyReduction_550+happyReduction_550 happy_x_1+	 =  case happyOut220 happy_x_1 of { happy_var_1 -> +	happyIn204+		 (happy_var_1+	)}++happyReduce_551 = happySpecReduce_3  193# happyReduction_551+happyReduction_551 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 BackQuote) -> +	case happyOut211 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 BackQuote) -> +	happyIn204+		 (fmap (const (happy_var_1 <^^> happy_var_3 <** [happy_var_1, srcInfoSpan (ann happy_var_2), happy_var_3])) happy_var_2+	)}}}++happyReduce_552 = happySpecReduce_1  194# happyReduction_552+happyReduction_552 happy_x_1+	 =  case happyOut218 happy_x_1 of { happy_var_1 -> +	happyIn205+		 (happy_var_1+	)}++happyReduce_553 = happySpecReduce_3  194# happyReduction_553+happyReduction_553 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 BackQuote) -> +	case happyOut216 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 BackQuote) -> +	happyIn205+		 (fmap (const (happy_var_1 <^^> happy_var_3 <** [happy_var_1, srcInfoSpan (ann happy_var_2), happy_var_3])) happy_var_2+	)}}}++happyReduce_554 = happySpecReduce_1  195# happyReduction_554+happyReduction_554 happy_x_1+	 =  case happyOut210 happy_x_1 of { happy_var_1 -> +	happyIn206+		 (happy_var_1+	)}++happyReduce_555 = happySpecReduce_3  195# happyReduction_555+happyReduction_555 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 BackQuote) -> +	case happyOut215 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 BackQuote) -> +	happyIn206+		 (fmap (const (happy_var_1 <^^> happy_var_3 <** [happy_var_1, srcInfoSpan (ann happy_var_2), happy_var_3])) happy_var_2+	)}}}++happyReduce_556 = happySpecReduce_1  196# happyReduction_556+happyReduction_556 happy_x_1+	 =  case happyOut202 happy_x_1 of { happy_var_1 -> +	happyIn207+		 (VarOp (ann happy_var_1) happy_var_1+	)}++happyReduce_557 = happySpecReduce_1  196# happyReduction_557+happyReduction_557 happy_x_1+	 =  case happyOut205 happy_x_1 of { happy_var_1 -> +	happyIn207+		 (ConOp (ann happy_var_1) happy_var_1+	)}++happyReduce_558 = happySpecReduce_1  197# happyReduction_558+happyReduction_558 happy_x_1+	 =  case happyOut203 happy_x_1 of { happy_var_1 -> +	happyIn208+		 (QVarOp (ann happy_var_1) happy_var_1+	)}++happyReduce_559 = happySpecReduce_1  197# happyReduction_559+happyReduction_559 happy_x_1+	 =  case happyOut206 happy_x_1 of { happy_var_1 -> +	happyIn208+		 (QConOp (ann happy_var_1) happy_var_1+	)}++happyReduce_560 = happySpecReduce_1  198# happyReduction_560+happyReduction_560 happy_x_1+	 =  case happyOut204 happy_x_1 of { happy_var_1 -> +	happyIn209+		 (QVarOp (ann happy_var_1) happy_var_1+	)}++happyReduce_561 = happySpecReduce_1  198# happyReduction_561+happyReduction_561 happy_x_1+	 =  case happyOut206 happy_x_1 of { happy_var_1 -> +	happyIn209+		 (QConOp (ann happy_var_1) happy_var_1+	)}++happyReduce_562 = happySpecReduce_1  199# happyReduction_562+happyReduction_562 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Colon) -> +	happyIn210+		 (list_cons_name (nIS happy_var_1)+	)}++happyReduce_563 = happySpecReduce_1  199# happyReduction_563+happyReduction_563 happy_x_1+	 =  case happyOut217 happy_x_1 of { happy_var_1 -> +	happyIn210+		 (happy_var_1+	)}++happyReduce_564 = happySpecReduce_1  200# happyReduction_564+happyReduction_564 happy_x_1+	 =  case happyOut213 happy_x_1 of { happy_var_1 -> +	happyIn211+		 (UnQual (ann happy_var_1) happy_var_1+	)}++happyReduce_565 = happySpecReduce_1  200# happyReduction_565+happyReduction_565 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn211+		 (let {Loc l (QVarId q) = happy_var_1; nis = nIS l}+                                 in Qual nis (ModuleName nis (fst q)) (Ident nis (snd q))+	)}++happyReduce_566 = happySpecReduce_1  201# happyReduction_566+happyReduction_566 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn212+		 (let Loc l (VarId v) = happy_var_1 in Ident (nIS l) v+	)}++happyReduce_567 = happySpecReduce_1  201# happyReduction_567+happyReduction_567 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_As) -> +	happyIn212+		 (as_name        (nIS happy_var_1)+	)}++happyReduce_568 = happySpecReduce_1  201# happyReduction_568+happyReduction_568 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Qualified) -> +	happyIn212+		 (qualified_name (nIS happy_var_1)+	)}++happyReduce_569 = happySpecReduce_1  201# happyReduction_569+happyReduction_569 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Hiding) -> +	happyIn212+		 (hiding_name    (nIS happy_var_1)+	)}++happyReduce_570 = happySpecReduce_1  201# happyReduction_570+happyReduction_570 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Export) -> +	happyIn212+		 (export_name    (nIS happy_var_1)+	)}++happyReduce_571 = happySpecReduce_1  201# happyReduction_571+happyReduction_571 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_StdCall) -> +	happyIn212+		 (stdcall_name   (nIS happy_var_1)+	)}++happyReduce_572 = happySpecReduce_1  201# happyReduction_572+happyReduction_572 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_CCall) -> +	happyIn212+		 (ccall_name     (nIS happy_var_1)+	)}++happyReduce_573 = happySpecReduce_1  201# happyReduction_573+happyReduction_573 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_CPlusPlus) -> +	happyIn212+		 (cplusplus_name (nIS happy_var_1)+	)}++happyReduce_574 = happySpecReduce_1  201# happyReduction_574+happyReduction_574 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_DotNet) -> +	happyIn212+		 (dotnet_name    (nIS happy_var_1)+	)}++happyReduce_575 = happySpecReduce_1  201# happyReduction_575+happyReduction_575 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Jvm) -> +	happyIn212+		 (jvm_name       (nIS happy_var_1)+	)}++happyReduce_576 = happySpecReduce_1  201# happyReduction_576+happyReduction_576 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Js) -> +	happyIn212+		 (js_name        (nIS happy_var_1)+	)}++happyReduce_577 = happySpecReduce_1  202# happyReduction_577+happyReduction_577 happy_x_1+	 =  case happyOut212 happy_x_1 of { happy_var_1 -> +	happyIn213+		 (happy_var_1+	)}++happyReduce_578 = happySpecReduce_1  202# happyReduction_578+happyReduction_578 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Safe) -> +	happyIn213+		 (safe_name       (nIS happy_var_1)+	)}++happyReduce_579 = happySpecReduce_1  202# happyReduction_579+happyReduction_579 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Unsafe) -> +	happyIn213+		 (unsafe_name     (nIS happy_var_1)+	)}++happyReduce_580 = happySpecReduce_1  202# happyReduction_580+happyReduction_580 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Threadsafe) -> +	happyIn213+		 (threadsafe_name (nIS happy_var_1)+	)}++happyReduce_581 = happySpecReduce_1  202# happyReduction_581+happyReduction_581 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Forall) -> +	happyIn213+		 (forall_name	  (nIS happy_var_1)+	)}++happyReduce_582 = happySpecReduce_1  202# happyReduction_582+happyReduction_582 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Family) -> +	happyIn213+		 (family_name     (nIS happy_var_1)+	)}++happyReduce_583 = happySpecReduce_1  203# happyReduction_583+happyReduction_583 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn214+		 (let Loc l (IDupVarId i) = happy_var_1 in IPDup (nIS l) i+	)}++happyReduce_584 = happySpecReduce_1  203# happyReduction_584+happyReduction_584 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn214+		 (let Loc l (ILinVarId i) = happy_var_1 in IPLin (nIS l) i+	)}++happyReduce_585 = happySpecReduce_1  204# happyReduction_585+happyReduction_585 happy_x_1+	 =  case happyOut216 happy_x_1 of { happy_var_1 -> +	happyIn215+		 (UnQual (ann happy_var_1) happy_var_1+	)}++happyReduce_586 = happySpecReduce_1  204# happyReduction_586+happyReduction_586 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn215+		 (let {Loc l (QConId q) = happy_var_1; nis = nIS l} in Qual nis (ModuleName nis (fst q)) (Ident nis (snd q))+	)}++happyReduce_587 = happySpecReduce_1  205# happyReduction_587+happyReduction_587 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn216+		 (let Loc l (ConId c) = happy_var_1 in Ident (nIS l) c+	)}++happyReduce_588 = happySpecReduce_1  206# happyReduction_588+happyReduction_588 happy_x_1+	 =  case happyOut218 happy_x_1 of { happy_var_1 -> +	happyIn217+		 (UnQual (ann happy_var_1) happy_var_1+	)}++happyReduce_589 = happySpecReduce_1  206# happyReduction_589+happyReduction_589 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn217+		 (let {Loc l (QConSym q) = happy_var_1; nis = nIS l} in Qual nis (ModuleName nis (fst q)) (Symbol nis (snd q))+	)}++happyReduce_590 = happySpecReduce_1  207# happyReduction_590+happyReduction_590 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn218+		 (let Loc l (ConSym c) = happy_var_1 in Symbol (nIS l) c+	)}++happyReduce_591 = happySpecReduce_1  208# happyReduction_591+happyReduction_591 happy_x_1+	 =  case happyOut221 happy_x_1 of { happy_var_1 -> +	happyIn219+		 (UnQual (ann happy_var_1) happy_var_1+	)}++happyReduce_592 = happySpecReduce_1  208# happyReduction_592+happyReduction_592 happy_x_1+	 =  case happyOut223 happy_x_1 of { happy_var_1 -> +	happyIn219+		 (happy_var_1+	)}++happyReduce_593 = happySpecReduce_1  209# happyReduction_593+happyReduction_593 happy_x_1+	 =  case happyOut222 happy_x_1 of { happy_var_1 -> +	happyIn220+		 (UnQual (ann happy_var_1) happy_var_1+	)}++happyReduce_594 = happySpecReduce_1  209# happyReduction_594+happyReduction_594 happy_x_1+	 =  case happyOut223 happy_x_1 of { happy_var_1 -> +	happyIn220+		 (happy_var_1+	)}++happyReduce_595 = happySpecReduce_1  210# happyReduction_595+happyReduction_595 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn221+		 (let Loc l (VarSym v) = happy_var_1 in Symbol (nIS l) v+	)}++happyReduce_596 = happySpecReduce_1  210# happyReduction_596+happyReduction_596 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Minus) -> +	happyIn221+		 (minus_name (nIS happy_var_1)+	)}++happyReduce_597 = happySpecReduce_1  210# happyReduction_597+happyReduction_597 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Exclamation) -> +	happyIn221+		 (bang_name  (nIS happy_var_1)+	)}++happyReduce_598 = happySpecReduce_1  210# happyReduction_598+happyReduction_598 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Dot) -> +	happyIn221+		 (dot_name   (nIS happy_var_1)+	)}++happyReduce_599 = happySpecReduce_1  210# happyReduction_599+happyReduction_599 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Star) -> +	happyIn221+		 (star_name  (nIS happy_var_1)+	)}++happyReduce_600 = happySpecReduce_1  211# happyReduction_600+happyReduction_600 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn222+		 (let Loc l (VarSym v) = happy_var_1 in Symbol (nIS l) v+	)}++happyReduce_601 = happySpecReduce_1  211# happyReduction_601+happyReduction_601 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Exclamation) -> +	happyIn222+		 (bang_name (nIS happy_var_1)+	)}++happyReduce_602 = happySpecReduce_1  211# happyReduction_602+happyReduction_602 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Dot) -> +	happyIn222+		 (dot_name  (nIS happy_var_1)+	)}++happyReduce_603 = happySpecReduce_1  211# happyReduction_603+happyReduction_603 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 Star) -> +	happyIn222+		 (star_name (nIS happy_var_1)+	)}++happyReduce_604 = happySpecReduce_1  212# happyReduction_604+happyReduction_604 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn223+		 (let {Loc l (QVarSym q) = happy_var_1; nis = nIS l} in Qual nis (ModuleName nis (fst q)) (Symbol nis (snd q))+	)}++happyReduce_605 = happySpecReduce_1  213# happyReduction_605+happyReduction_605 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn224+		 (let Loc l (IntTok        (i,raw)) = happy_var_1 in Int        (nIS l) i raw+	)}++happyReduce_606 = happySpecReduce_1  213# happyReduction_606+happyReduction_606 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn224+		 (let Loc l (Character     (c,raw)) = happy_var_1 in Char       (nIS l) c raw+	)}++happyReduce_607 = happySpecReduce_1  213# happyReduction_607+happyReduction_607 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn224+		 (let Loc l (FloatTok      (r,raw)) = happy_var_1 in Frac       (nIS l) r raw+	)}++happyReduce_608 = happySpecReduce_1  213# happyReduction_608+happyReduction_608 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn224+		 (let Loc l (StringTok     (s,raw)) = happy_var_1 in String     (nIS l) s raw+	)}++happyReduce_609 = happySpecReduce_1  213# happyReduction_609+happyReduction_609 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn224+		 (let Loc l (IntTokHash    (i,raw)) = happy_var_1 in PrimInt    (nIS l) i raw+	)}++happyReduce_610 = happySpecReduce_1  213# happyReduction_610+happyReduction_610 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn224+		 (let Loc l (WordTokHash   (w,raw)) = happy_var_1 in PrimWord   (nIS l) w raw+	)}++happyReduce_611 = happySpecReduce_1  213# happyReduction_611+happyReduction_611 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn224+		 (let Loc l (FloatTokHash  (f,raw)) = happy_var_1 in PrimFloat  (nIS l) f raw+	)}++happyReduce_612 = happySpecReduce_1  213# happyReduction_612+happyReduction_612 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn224+		 (let Loc l (DoubleTokHash (d,raw)) = happy_var_1 in PrimDouble (nIS l) d raw+	)}++happyReduce_613 = happySpecReduce_1  213# happyReduction_613+happyReduction_613 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn224+		 (let Loc l (CharacterHash (c,raw)) = happy_var_1 in PrimChar   (nIS l) c raw+	)}++happyReduce_614 = happySpecReduce_1  213# happyReduction_614+happyReduction_614 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn224+		 (let Loc l (StringHash    (s,raw)) = happy_var_1 in PrimString (nIS l) s raw+	)}++happyReduce_615 = happyMonadReduce 0# 214# happyReduction_615+happyReduction_615 (happyRest) tk+	 = happyThen (( pushCurrentContext >> getSrcLoc >>= \s -> return $ mkSrcSpan s s {- >>= \x -> trace (show x) (return x) -})+	) (\r -> happyReturn (happyIn225 r))++happyReduce_616 = happySpecReduce_1  215# happyReduction_616+happyReduction_616 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 VRightCurly) -> +	happyIn226+		 (happy_var_1 {- >>= \x -> trace (show x ++ show x ++ show x) (return x) -}+	)}++happyReduce_617 = happyMonadReduce 1# 215# happyReduction_617+happyReduction_617 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen (( popContext >> getSrcLoc >>= \s -> return $ mkSrcSpan s s {- >>= \x -> trace (show x ++ show x) (return x) -})+	) (\r -> happyReturn (happyIn226 r))++happyReduce_618 = happySpecReduce_1  216# happyReduction_618+happyReduction_618 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn227+		 (let Loc l (ConId  n) = happy_var_1 in ModuleName (nIS l) n+	)}++happyReduce_619 = happySpecReduce_1  216# happyReduction_619+happyReduction_619 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn227+		 (let Loc l (QConId n) = happy_var_1 in ModuleName (nIS l) (fst n ++ '.':snd n)+	)}++happyReduce_620 = happySpecReduce_1  217# happyReduction_620+happyReduction_620 happy_x_1+	 =  case happyOut200 happy_x_1 of { happy_var_1 -> +	happyIn228+		 (happy_var_1+	)}++happyReduce_621 = happySpecReduce_1  218# happyReduction_621+happyReduction_621 happy_x_1+	 =  case happyOut201 happy_x_1 of { happy_var_1 -> +	happyIn229+		 (happy_var_1+	)}++happyReduce_622 = happySpecReduce_1  219# happyReduction_622+happyReduction_622 happy_x_1+	 =  case happyOut231 happy_x_1 of { happy_var_1 -> +	happyIn230+		 (happy_var_1+	)}++happyReduce_623 = happySpecReduce_1  220# happyReduction_623+happyReduction_623 happy_x_1+	 =  case happyOut212 happy_x_1 of { happy_var_1 -> +	happyIn231+		 (happy_var_1+	)}++happyReduce_624 = happySpecReduce_1  220# happyReduction_624+happyReduction_624 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Safe) -> +	happyIn231+		 (safe_name       (nIS happy_var_1)+	)}++happyReduce_625 = happySpecReduce_1  220# happyReduction_625+happyReduction_625 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Unsafe) -> +	happyIn231+		 (unsafe_name     (nIS happy_var_1)+	)}++happyReduce_626 = happySpecReduce_1  220# happyReduction_626+happyReduction_626 happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 KW_Threadsafe) -> +	happyIn231+		 (threadsafe_name (nIS happy_var_1)+	)}++happyReduce_627 = happySpecReduce_3  221# happyReduction_627+happyReduction_627 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { (Loc happy_var_1 BackQuote) -> +	case happyOut230 happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { (Loc happy_var_3 BackQuote) -> +	happyIn232+		 (UnQual (happy_var_1 <^^> happy_var_3 <** [happy_var_1, srcInfoSpan (ann happy_var_2), happy_var_3]) happy_var_2+	)}}}++happyReduce_628 = happySpecReduce_1  221# happyReduction_628+happyReduction_628 happy_x_1+	 =  case happyOut233 happy_x_1 of { happy_var_1 -> +	happyIn232+		 (UnQual (ann happy_var_1) happy_var_1+	)}++happyReduce_629 = happySpecReduce_1  222# happyReduction_629+happyReduction_629 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn233+		 (let Loc l (VarSym x) = happy_var_1 in Symbol (nIS l) x+	)}++happyNewToken action sts stk+	= lexer(\tk -> +	let cont i = happyDoAction i tk action sts stk in+	case tk of {+	Loc _ EOF -> happyDoAction 140# tk action sts stk;+	Loc _ (VarId _) -> cont 1#;+	Loc _ (QVarId _) -> cont 2#;+	Loc _ (IDupVarId _) -> cont 3#;+	Loc _ (ILinVarId _) -> cont 4#;+	Loc _ (ConId _) -> cont 5#;+	Loc _ (QConId _) -> cont 6#;+	Loc _ (DVarId _) -> cont 7#;+	Loc _ (VarSym _) -> cont 8#;+	Loc _ (ConSym _) -> cont 9#;+	Loc _ (QVarSym _) -> cont 10#;+	Loc _ (QConSym _) -> cont 11#;+	Loc _ (IntTok _) -> cont 12#;+	Loc _ (FloatTok _) -> cont 13#;+	Loc _ (Character _) -> cont 14#;+	Loc _ (StringTok _) -> cont 15#;+	Loc _ (IntTokHash _) -> cont 16#;+	Loc _ (WordTokHash _) -> cont 17#;+	Loc _ (FloatTokHash _) -> cont 18#;+	Loc _ (DoubleTokHash _) -> cont 19#;+	Loc _ (CharacterHash _) -> cont 20#;+	Loc _ (StringHash _) -> cont 21#;+	Loc happy_dollar_dollar LeftParen -> cont 22#;+	Loc happy_dollar_dollar RightParen -> cont 23#;+	Loc happy_dollar_dollar LeftHashParen -> cont 24#;+	Loc happy_dollar_dollar RightHashParen -> cont 25#;+	Loc happy_dollar_dollar LeftCurlyBar -> cont 26#;+	Loc happy_dollar_dollar RightCurlyBar -> cont 27#;+	Loc happy_dollar_dollar SemiColon -> cont 28#;+	Loc happy_dollar_dollar LeftCurly -> cont 29#;+	Loc happy_dollar_dollar RightCurly -> cont 30#;+	Loc happy_dollar_dollar VRightCurly -> cont 31#;+	Loc happy_dollar_dollar LeftSquare -> cont 32#;+	Loc happy_dollar_dollar RightSquare -> cont 33#;+	Loc happy_dollar_dollar Comma -> cont 34#;+	Loc happy_dollar_dollar Underscore -> cont 35#;+	Loc happy_dollar_dollar BackQuote -> cont 36#;+	Loc happy_dollar_dollar Dot -> cont 37#;+	Loc happy_dollar_dollar DotDot -> cont 38#;+	Loc happy_dollar_dollar Colon -> cont 39#;+	Loc happy_dollar_dollar DoubleColon -> cont 40#;+	Loc happy_dollar_dollar Equals -> cont 41#;+	Loc happy_dollar_dollar Backslash -> cont 42#;+	Loc happy_dollar_dollar Bar -> cont 43#;+	Loc happy_dollar_dollar LeftArrow -> cont 44#;+	Loc happy_dollar_dollar RightArrow -> cont 45#;+	Loc happy_dollar_dollar At -> cont 46#;+	Loc happy_dollar_dollar Tilde -> cont 47#;+	Loc happy_dollar_dollar DoubleArrow -> cont 48#;+	Loc happy_dollar_dollar Minus -> cont 49#;+	Loc happy_dollar_dollar Exclamation -> cont 50#;+	Loc happy_dollar_dollar Star -> cont 51#;+	Loc happy_dollar_dollar LeftArrowTail -> cont 52#;+	Loc happy_dollar_dollar RightArrowTail -> cont 53#;+	Loc happy_dollar_dollar LeftDblArrowTail -> cont 54#;+	Loc happy_dollar_dollar RightDblArrowTail -> cont 55#;+	Loc happy_dollar_dollar RPGuardOpen -> cont 56#;+	Loc happy_dollar_dollar RPGuardClose -> cont 57#;+	Loc happy_dollar_dollar RPCAt -> cont 58#;+	Loc _ (THIdEscape _) -> cont 59#;+	Loc happy_dollar_dollar THParenEscape -> cont 60#;+	Loc happy_dollar_dollar THExpQuote -> cont 61#;+	Loc happy_dollar_dollar THPatQuote -> cont 62#;+	Loc happy_dollar_dollar THTypQuote -> cont 63#;+	Loc happy_dollar_dollar THDecQuote -> cont 64#;+	Loc happy_dollar_dollar THCloseQuote -> cont 65#;+	Loc happy_dollar_dollar THVarQuote -> cont 66#;+	Loc happy_dollar_dollar THTyQuote -> cont 67#;+	Loc _ (THQuasiQuote _) -> cont 68#;+	Loc _ (XPCDATA _) -> cont 69#;+	Loc happy_dollar_dollar XStdTagOpen -> cont 70#;+	Loc happy_dollar_dollar XCloseTagOpen -> cont 71#;+	Loc happy_dollar_dollar XCodeTagOpen -> cont 72#;+	Loc happy_dollar_dollar XChildTagOpen -> cont 73#;+	Loc happy_dollar_dollar XStdTagClose -> cont 74#;+	Loc happy_dollar_dollar XEmptyTagClose -> cont 75#;+	Loc happy_dollar_dollar XCodeTagClose -> cont 76#;+	Loc happy_dollar_dollar XRPatOpen -> cont 77#;+	Loc happy_dollar_dollar XRPatClose -> cont 78#;+	Loc happy_dollar_dollar KW_Foreign -> cont 79#;+	Loc happy_dollar_dollar KW_Export -> cont 80#;+	Loc happy_dollar_dollar KW_Safe -> cont 81#;+	Loc happy_dollar_dollar KW_Unsafe -> cont 82#;+	Loc happy_dollar_dollar KW_Threadsafe -> cont 83#;+	Loc happy_dollar_dollar KW_Interruptible -> cont 84#;+	Loc happy_dollar_dollar KW_StdCall -> cont 85#;+	Loc happy_dollar_dollar KW_CCall -> cont 86#;+	Loc happy_dollar_dollar KW_CPlusPlus -> cont 87#;+	Loc happy_dollar_dollar KW_DotNet -> cont 88#;+	Loc happy_dollar_dollar KW_Jvm -> cont 89#;+	Loc happy_dollar_dollar KW_Js -> cont 90#;+	Loc happy_dollar_dollar KW_CApi -> cont 91#;+	Loc happy_dollar_dollar KW_As -> cont 92#;+	Loc happy_dollar_dollar KW_By -> cont 93#;+	Loc happy_dollar_dollar KW_Case -> cont 94#;+	Loc happy_dollar_dollar KW_Class -> cont 95#;+	Loc happy_dollar_dollar KW_Data -> cont 96#;+	Loc happy_dollar_dollar KW_Default -> cont 97#;+	Loc happy_dollar_dollar KW_Deriving -> cont 98#;+	Loc happy_dollar_dollar KW_Do -> cont 99#;+	Loc happy_dollar_dollar KW_Else -> cont 100#;+	Loc happy_dollar_dollar KW_Family -> cont 101#;+	Loc happy_dollar_dollar KW_Forall -> cont 102#;+	Loc happy_dollar_dollar KW_Group -> cont 103#;+	Loc happy_dollar_dollar KW_Hiding -> cont 104#;+	Loc happy_dollar_dollar KW_If -> cont 105#;+	Loc happy_dollar_dollar KW_Import -> cont 106#;+	Loc happy_dollar_dollar KW_In -> cont 107#;+	Loc happy_dollar_dollar KW_Infix -> cont 108#;+	Loc happy_dollar_dollar KW_InfixL -> cont 109#;+	Loc happy_dollar_dollar KW_InfixR -> cont 110#;+	Loc happy_dollar_dollar KW_Instance -> cont 111#;+	Loc happy_dollar_dollar KW_Let -> cont 112#;+	Loc happy_dollar_dollar KW_MDo -> cont 113#;+	Loc happy_dollar_dollar KW_Module -> cont 114#;+	Loc happy_dollar_dollar KW_NewType -> cont 115#;+	Loc happy_dollar_dollar KW_Of -> cont 116#;+	Loc happy_dollar_dollar KW_Proc -> cont 117#;+	Loc happy_dollar_dollar KW_Rec -> cont 118#;+	Loc happy_dollar_dollar KW_Then -> cont 119#;+	Loc happy_dollar_dollar KW_Type -> cont 120#;+	Loc happy_dollar_dollar KW_Using -> cont 121#;+	Loc happy_dollar_dollar KW_Where -> cont 122#;+	Loc happy_dollar_dollar KW_Qualified -> cont 123#;+	Loc _ (INLINE _) -> cont 124#;+	Loc happy_dollar_dollar INLINE_CONLIKE -> cont 125#;+	Loc happy_dollar_dollar SPECIALISE -> cont 126#;+	Loc _ (SPECIALISE_INLINE _) -> cont 127#;+	Loc happy_dollar_dollar SOURCE -> cont 128#;+	Loc happy_dollar_dollar RULES -> cont 129#;+	Loc happy_dollar_dollar CORE -> cont 130#;+	Loc happy_dollar_dollar SCC -> cont 131#;+	Loc happy_dollar_dollar GENERATED -> cont 132#;+	Loc happy_dollar_dollar DEPRECATED -> cont 133#;+	Loc happy_dollar_dollar WARNING -> cont 134#;+	Loc happy_dollar_dollar UNPACK -> cont 135#;+	Loc _ (OPTIONS _) -> cont 136#;+	Loc happy_dollar_dollar LANGUAGE -> cont 137#;+	Loc happy_dollar_dollar ANN -> cont 138#;+	Loc happy_dollar_dollar PragmaEnd -> cont 139#;+	_ -> happyError' tk+	})++happyError_ 140# tk = happyError' tk+happyError_ _ tk = happyError' tk++happyThen :: () => P a -> (a -> P b) -> P b+happyThen = (>>=)+happyReturn :: () => a -> P a+happyReturn = (return)+happyThen1 = happyThen+happyReturn1 :: () => a -> P a+happyReturn1 = happyReturn+happyError' :: () => (Loc Token) -> P a+happyError' tk = parseError tk++mparseModule = happySomeParser where+  happySomeParser = happyThen (happyParse 0#) (\x -> happyReturn (happyOut13 x))++mparseExp = happySomeParser where+  happySomeParser = happyThen (happyParse 1#) (\x -> happyReturn (happyOut139 x))++mparsePat = happySomeParser where+  happySomeParser = happyThen (happyParse 2#) (\x -> happyReturn (happyOut185 x))++mparseDecl = happySomeParser where+  happySomeParser = happyThen (happyParse 3#) (\x -> happyReturn (happyOut50 x))++mparseType = happySomeParser where+  happySomeParser = happyThen (happyParse 4#) (\x -> happyReturn (happyOut88 x))++mparseStmt = happySomeParser where+  happySomeParser = happyThen (happyParse 5#) (\x -> happyReturn (happyOut189 x))++mparseModules = happySomeParser where+  happySomeParser = happyThen (happyParse 6#) (\x -> happyReturn (happyOut11 x))++mfindOptPragmas = happySomeParser where+  happySomeParser = happyThen (happyParse 7#) (\x -> happyReturn (happyOut15 x))++happySeq = happyDontSeq+++type L = SrcSpanInfo -- just for convenience+type S = SrcSpan++parseError :: Loc Token -> P a+parseError t = fail $ "Parse error: " ++ showToken (unLoc t)++(<>) :: (Annotated a, Annotated b) => a SrcSpanInfo -> b SrcSpanInfo -> SrcSpanInfo+a <> b = ann a <++> ann b+infixl 6 <>++nIS = noInfoSpan+iS = infoSpan+++-- | Parse of a string, which should contain a complete Haskell module.+parseModule :: String -> ParseResult (Module SrcSpanInfo)+parseModule = simpleParse mparseModule++-- | Parse of a string containing a complete Haskell module, using an explicit mode.+parseModuleWithMode :: ParseMode -> String -> ParseResult (Module SrcSpanInfo)+parseModuleWithMode = modeParse mparseModule++-- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.+parseModuleWithComments :: ParseMode -> String -> ParseResult (Module SrcSpanInfo, [Comment])+parseModuleWithComments = commentParse mparseModule++-- | Parse of a string containing a Haskell expression.+parseExp :: String -> ParseResult (Exp SrcSpanInfo)+parseExp = simpleParse mparseExp++-- | Parse of a string containing a Haskell expression, using an explicit mode.+parseExpWithMode :: ParseMode -> String -> ParseResult (Exp SrcSpanInfo)+parseExpWithMode = modeParse mparseExp++-- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.+parseExpWithComments :: ParseMode -> String -> ParseResult (Exp SrcSpanInfo, [Comment])+parseExpWithComments = commentParse mparseExp++-- | Parse of a string containing a Haskell pattern.+parsePat :: String -> ParseResult (Pat SrcSpanInfo)+parsePat = simpleParse mparsePat++-- | Parse of a string containing a Haskell pattern, using an explicit mode.+parsePatWithMode :: ParseMode -> String -> ParseResult (Pat SrcSpanInfo)+parsePatWithMode = modeParse mparsePat++-- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.+parsePatWithComments :: ParseMode -> String -> ParseResult (Pat SrcSpanInfo, [Comment])+parsePatWithComments = commentParse mparsePat++-- | Parse of a string containing a Haskell top-level declaration.+parseDecl :: String -> ParseResult (Decl SrcSpanInfo)+parseDecl = simpleParse mparseDecl++-- | Parse of a string containing a Haskell top-level declaration, using an explicit mode.+parseDeclWithMode :: ParseMode -> String -> ParseResult (Decl SrcSpanInfo)+parseDeclWithMode = modeParse mparseDecl++-- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.+parseDeclWithComments :: ParseMode -> String -> ParseResult (Decl SrcSpanInfo, [Comment])+parseDeclWithComments = commentParse mparseDecl++-- | Parse of a string containing a Haskell type.+parseType :: String -> ParseResult (Type SrcSpanInfo)+parseType = runParser mparseType++-- | Parse of a string containing a Haskell type, using an explicit mode.+parseTypeWithMode :: ParseMode -> String -> ParseResult (Type SrcSpanInfo)+parseTypeWithMode mode = runParserWithMode mode mparseType++-- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.+parseTypeWithComments :: ParseMode -> String -> ParseResult (Type SrcSpanInfo, [Comment])+parseTypeWithComments mode str = runParserWithModeComments mode mparseType str++-- | Parse of a string containing a Haskell statement.+parseStmt :: String -> ParseResult (Stmt SrcSpanInfo)+parseStmt = runParser mparseStmt++-- | Parse of a string containing a Haskell type, using an explicit mode.+parseStmtWithMode :: ParseMode -> String -> ParseResult (Stmt SrcSpanInfo)+parseStmtWithMode mode = runParserWithMode mode mparseStmt++-- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.+parseStmtWithComments :: ParseMode -> String -> ParseResult (Stmt SrcSpanInfo, [Comment])+parseStmtWithComments mode str = runParserWithModeComments mode mparseStmt str+++simpleParse :: AppFixity a => P (a L) -> String -> ParseResult (a L)+simpleParse p = applyFixities preludeFixities <=< runParser p++modeParse :: AppFixity a => P (a L) -> ParseMode -> String -> ParseResult (a L)+modeParse p mode = applyFixities' (fixities mode) <=< runParserWithMode mode p++commentParse :: AppFixity a => P (a L) -> ParseMode -> String -> ParseResult (a L, [Comment])+commentParse p mode str = do (ast, cs) <- runParserWithModeComments mode p str+                             ast' <- applyFixities' (fixities mode) ast+                             return (ast', cs)++-- | Partial parse of a string starting with a series of top-level option pragmas.+getTopPragmas :: String -> ParseResult [ModulePragma SrcSpanInfo]+getTopPragmas = runParser (mfindOptPragmas >>= \(ps,_,_) -> return ps)++-- | Parse of a string, which should contain a complete Haskell module.+parseModules :: String -> ParseResult [Module SrcSpanInfo]+parseModules = mapM (applyFixities preludeFixities) <=< runParser mparseModules++-- | Parse of a string containing a complete Haskell module, using an explicit mode.+parseModulesWithMode :: ParseMode -> String -> ParseResult [Module SrcSpanInfo]+parseModulesWithMode mode = mapM (applyFixities' (fixities mode)) <=< runParserWithMode mode mparseModules++-- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.+parseModulesWithComments :: ParseMode -> String -> ParseResult ([Module SrcSpanInfo], [Comment])+parseModulesWithComments mode str = do (ast,cs) <- runParserWithModeComments mode mparseModules str+                                       ast' <- mapM (applyFixities' (fixities mode)) ast+                                       return (ast', cs)+applyFixities' :: (AppFixity a) => Maybe [Fixity] -> a L -> ParseResult (a L)+applyFixities' Nothing ast = return ast+applyFixities' (Just fixs) ast = applyFixities fixs ast+{-# LINE 1 "templates/GenericTemplate.hs" #-}+{-# LINE 1 "templates/GenericTemplate.hs" #-}+{-# LINE 1 "<built-in>" #-}+{-# LINE 1 "<command-line>" #-}+{-# LINE 1 "templates/GenericTemplate.hs" #-}+-- Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp ++{-# LINE 30 "templates/GenericTemplate.hs" #-}+++data Happy_IntList = HappyCons Happy_GHC_Exts.Int# Happy_IntList++++++{-# LINE 51 "templates/GenericTemplate.hs" #-}++{-# LINE 61 "templates/GenericTemplate.hs" #-}++{-# LINE 70 "templates/GenericTemplate.hs" #-}++infixr 9 `HappyStk`+data HappyStk a = HappyStk a (HappyStk a)++-----------------------------------------------------------------------------+-- starting the parse++happyParse start_state = happyNewToken start_state notHappyAtAll notHappyAtAll++-----------------------------------------------------------------------------+-- Accepting the parse++-- If the current token is 0#, it means we've just accepted a partial+-- parse (a %partial parser).  We must ignore the saved token on the top of+-- the stack in this case.+happyAccept 0# tk st sts (_ `HappyStk` ans `HappyStk` _) =+	happyReturn1 ans+happyAccept j tk st sts (HappyStk ans _) = +	(happyTcHack j (happyTcHack st)) (happyReturn1 ans)++-----------------------------------------------------------------------------+-- Arrays only: do the next action++++happyDoAction i tk st+	= {- nothing -}+++	  case action of+		0#		  -> {- nothing -}+				     happyFail i tk st+		-1# 	  -> {- nothing -}+				     happyAccept i tk st+		n | (n Happy_GHC_Exts.<# (0# :: Happy_GHC_Exts.Int#)) -> {- nothing -}++				     (happyReduceArr Happy_Data_Array.! rule) i tk st+				     where rule = (Happy_GHC_Exts.I# ((Happy_GHC_Exts.negateInt# ((n Happy_GHC_Exts.+# (1# :: Happy_GHC_Exts.Int#))))))+		n		  -> {- nothing -}+++				     happyShift new_state i tk st+				     where (new_state) = (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#))+   where (off)    = indexShortOffAddr happyActOffsets st+         (off_i)  = (off Happy_GHC_Exts.+# i)+	 check  = if (off_i Happy_GHC_Exts.>=# (0# :: Happy_GHC_Exts.Int#))+			then (indexShortOffAddr happyCheck off_i Happy_GHC_Exts.==#  i)+			else False+         (action)+          | check     = indexShortOffAddr happyTable off_i+          | otherwise = indexShortOffAddr happyDefActions st++{-# LINE 130 "templates/GenericTemplate.hs" #-}+++indexShortOffAddr (HappyA# arr) off =+	Happy_GHC_Exts.narrow16Int# i+  where+        i = Happy_GHC_Exts.word2Int# (Happy_GHC_Exts.or# (Happy_GHC_Exts.uncheckedShiftL# high 8#) low)+        high = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr (off' Happy_GHC_Exts.+# 1#)))+        low  = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr off'))+        off' = off Happy_GHC_Exts.*# 2#++++++data HappyAddr = HappyA# Happy_GHC_Exts.Addr#+++++-----------------------------------------------------------------------------+-- HappyState data type (not arrays)++{-# LINE 163 "templates/GenericTemplate.hs" #-}++-----------------------------------------------------------------------------+-- Shifting a token++happyShift new_state 0# tk st sts stk@(x `HappyStk` _) =+     let (i) = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in+--     trace "shifting the error token" $+     happyDoAction i tk new_state (HappyCons (st) (sts)) (stk)++happyShift new_state i tk st sts stk =+     happyNewToken new_state (HappyCons (st) (sts)) ((happyInTok (tk))`HappyStk`stk)++-- happyReduce is specialised for the common cases.++happySpecReduce_0 i fn 0# tk st sts stk+     = happyFail 0# tk st sts stk+happySpecReduce_0 nt fn j tk st@((action)) sts stk+     = happyGoto nt j tk st (HappyCons (st) (sts)) (fn `HappyStk` stk)++happySpecReduce_1 i fn 0# tk st sts stk+     = happyFail 0# tk st sts stk+happySpecReduce_1 nt fn j tk _ sts@((HappyCons (st@(action)) (_))) (v1`HappyStk`stk')+     = let r = fn v1 in+       happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))++happySpecReduce_2 i fn 0# tk st sts stk+     = happyFail 0# tk st sts stk+happySpecReduce_2 nt fn j tk _ (HappyCons (_) (sts@((HappyCons (st@(action)) (_))))) (v1`HappyStk`v2`HappyStk`stk')+     = let r = fn v1 v2 in+       happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))++happySpecReduce_3 i fn 0# tk st sts stk+     = happyFail 0# tk st sts stk+happySpecReduce_3 nt fn j tk _ (HappyCons (_) ((HappyCons (_) (sts@((HappyCons (st@(action)) (_))))))) (v1`HappyStk`v2`HappyStk`v3`HappyStk`stk')+     = let r = fn v1 v2 v3 in+       happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))++happyReduce k i fn 0# tk st sts stk+     = happyFail 0# tk st sts stk+happyReduce k nt fn j tk st sts stk+     = case happyDrop (k Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) sts of+	 sts1@((HappyCons (st1@(action)) (_))) ->+        	let r = fn stk in  -- it doesn't hurt to always seq here...+       		happyDoSeq r (happyGoto nt j tk st1 sts1 r)++happyMonadReduce k nt fn 0# tk st sts stk+     = happyFail 0# tk st sts stk+happyMonadReduce k nt fn j tk st sts stk =+        happyThen1 (fn stk tk) (\r -> happyGoto nt j tk st1 sts1 (r `HappyStk` drop_stk))+       where (sts1@((HappyCons (st1@(action)) (_)))) = happyDrop k (HappyCons (st) (sts))+             drop_stk = happyDropStk k stk++happyMonad2Reduce k nt fn 0# tk st sts stk+     = happyFail 0# tk st sts stk+happyMonad2Reduce k nt fn j tk st sts stk =+       happyThen1 (fn stk tk) (\r -> happyNewToken new_state sts1 (r `HappyStk` drop_stk))+       where (sts1@((HappyCons (st1@(action)) (_)))) = happyDrop k (HappyCons (st) (sts))+             drop_stk = happyDropStk k stk++             (off) = indexShortOffAddr happyGotoOffsets st1+             (off_i) = (off Happy_GHC_Exts.+# nt)+             (new_state) = indexShortOffAddr happyTable off_i+++++happyDrop 0# l = l+happyDrop n (HappyCons (_) (t)) = happyDrop (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) t++happyDropStk 0# l = l+happyDropStk n (x `HappyStk` xs) = happyDropStk (n Happy_GHC_Exts.-# (1#::Happy_GHC_Exts.Int#)) xs++-----------------------------------------------------------------------------+-- Moving to a new state after a reduction+++happyGoto nt j tk st = +   {- nothing -}+   happyDoAction j tk new_state+   where (off) = indexShortOffAddr happyGotoOffsets st+         (off_i) = (off Happy_GHC_Exts.+# nt)+         (new_state) = indexShortOffAddr happyTable off_i+++++-----------------------------------------------------------------------------+-- Error recovery (0# is the error token)++-- parse error if we are in recovery and we fail again+happyFail 0# tk old_st _ stk@(x `HappyStk` _) =+     let (i) = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in+--	trace "failing" $ +        happyError_ i tk++{-  We don't need state discarding for our restricted implementation of+    "error".  In fact, it can cause some bogus parses, so I've disabled it+    for now --SDM++-- discard a state+happyFail  0# tk old_st (HappyCons ((action)) (sts)) +						(saved_tok `HappyStk` _ `HappyStk` stk) =+--	trace ("discarding state, depth " ++ show (length stk))  $+	happyDoAction 0# tk action sts ((saved_tok`HappyStk`stk))+-}++-- Enter error recovery: generate an error token,+--                       save the old token and carry on.+happyFail  i tk (action) sts stk =+--      trace "entering error recovery" $+	happyDoAction 0# tk action sts ( (Happy_GHC_Exts.unsafeCoerce# (Happy_GHC_Exts.I# (i))) `HappyStk` stk)++-- Internal happy errors:++notHappyAtAll :: a+notHappyAtAll = error "Internal Happy error\n"++-----------------------------------------------------------------------------+-- Hack to get the typechecker to accept our action functions+++happyTcHack :: Happy_GHC_Exts.Int# -> a -> a happyTcHack x y = y {-# INLINE happyTcHack #-} 
haskell-src-exts.cabal view
@@ -1,5 +1,5 @@ Name:                   haskell-src-exts-Version:                1.13.5+Version:                1.14.0 License:                BSD3 License-File:           LICENSE Author:                 Niklas Broberg@@ -26,86 +26,101 @@                         Apart from these standard extensions,                         it also handles regular patterns as per the HaRP extension                         as well as HSX-style embedded XML syntax.-Homepage:               http://code.haskell.org/haskell-src-exts+Homepage:               https://github.com/haskell-suite/haskell-src-exts Stability:              Stable Tested-with:            GHC==6.10.2, GHC==6.10.4, GHC==6.12.3, GHC==7.0.2 Build-Type:             Custom-Cabal-Version:          >= 1.6+Cabal-Version:          >= 1.10  Extra-Source-Files: 			CHANGELOG-			Test/Runner.hs-			Test/failing.txt-			Test/printFail.txt+			Test/examples/ArityMismatch.hs 			Test/examples/ArrowLayout.hs 			Test/examples/Attributes.hs+			Test/examples/BadStringLineBreak.hs 			Test/examples/BangPatterns.hs 			Test/examples/Bug.hs 			Test/examples/ByteStringUtils.hs-			Test/examples/CParser.hs 			Test/examples/ClassInstType.hs+			Test/examples/ConstraintKinds.hs+			Test/examples/CParser.hs+			Test/examples/CStyleLinePragmas.hs 			Test/examples/DataHeadParen.hs 			Test/examples/Directory.hs+			Test/examples/DoRec.hs+			Test/examples/DoubleHashOp.hs 			Test/examples/EmptyAnn.hs 			Test/examples/EmptyContext.hs+			Test/examples/EmptyFunDepPremise.hs 			Test/examples/EmptyInstance.hs 			Test/examples/EmptyList.hs-			Test/examples/Ex1.hs+			Test/examples/ExtraEndBrace.hs 			Test/examples/FamilyKindSig.hs+			Test/examples/FamilyVarid.hs+                        Test/examples/FFIExtensions.hs 			Test/examples/FixityTests.hs+			Test/examples/ForallInInstance.hs 			Test/examples/ForeignImport.hs 			Test/examples/GadtDeriving.hs+			Test/examples/GADTRecord.hs 			Test/examples/GenericTree.hs 			Test/examples/GhcDeriving.hs 			Test/examples/GroupKeyword.hs 			Test/examples/HappyDoAction.hs 			Test/examples/HaskellParser.hs 			Test/examples/HexPrec.hs-			Test/examples/Hyphen.hs-			Test/examples/ImportSymbol.hs-                        Test/examples/IfThenElseLayout.hs+			Test/examples/IfThenElseLayout.hs+			Test/examples/IllDataTypeDecl.hs+			Test/examples/IndentedWhereBlock.hs 			Test/examples/IndentedWhere.hs 			Test/examples/InfixParser.hs-			Test/examples/LanguagePragma.hs+                        Test/examples/LambdaCase.hs 			Test/examples/LineOptionsPragma.hs-			Test/examples/LinePragma.hs-			Test/examples/ListComp1.hs-			Test/examples/MagicHash.hs 			Test/examples/MultiCtxt.hs-			Test/examples/NPlusK.hs+                        Test/examples/MultiWayIf.hs+			Test/examples/NegPrimWordLiteral.hs 			Test/examples/NestedAsPat.hs-			Test/examples/PackageImport.hs+			Test/examples/NonDecreasing.hs+			Test/examples/NPlusK.hs+                        Test/examples/ParallelListComp.hs 			Test/examples/ParenFunBind.hs-			Test/examples/Pragma.hs+			Test/examples/PrimitiveIntHexLiteral.hs+                        Test/examples/QQType.hs 			Test/examples/QualifiedDot.hs 			Test/examples/QuasiQuoteLines.hs-			Test/examples/Rank2Types.hs+			Test/examples/QuasiQuoteOld.hs+			Test/examples/QuasiQuoteSplice.hs+			Test/examples/RCategory.lhs 			Test/examples/ReadP.hs 			Test/examples/RealGHC.lhs-			Test/examples/RealHSE.hs-			Test/examples/RealHoogle.hs-			Test/examples/RealTagSoup.hs 			Test/examples/RecordInfixSelector.hs-			Test/examples/RecordWildcards.hs 			Test/examples/RelaxedDo.hs 			Test/examples/SCCPragmas.hs 			Test/examples/ScopedTypeVariables.hs 			Test/examples/SimpleDeriving.hs 			Test/examples/SingleClassAsst.hs 			Test/examples/SpecializeInstance.hs+			Test/examples/SpecializePhaseControl.hs 			Test/examples/Testing.hs+			Test/examples/THTypes.hs 			Test/examples/TupleSections.hs 			Test/examples/TypeFunctions.hs+			Test/examples/TypeOperatorAsVariable.hs 			Test/examples/TypeOperatorsTest.hs+			Test/examples/UnboxedSingleton.hs+			Test/examples/UnboxedTuples.hs 			Test/examples/Unicode.hs 			Test/examples/UnicodeSyntax.hs 			Test/examples/UnindentedPragmaClose.hs 			Test/examples/WhereBlock.hs-			Test/examples/WithKeyword.hs+			Test/failing.txt+			Test/printFail.txt+			Test/Runner.hs  Flag base4  Library+  Default-language:     Haskell98   Build-Tools:          happy >= 1.17   Build-Depends:        array >= 0.1, pretty >= 1.0, cpphs >= 1.3   if flag(base4)@@ -143,5 +158,19 @@   Hs-source-dirs:       src  Source-Repository head-        Type:           darcs-        Location:       http://code.haskell.org/haskell-src-exts+        Type:           git+        Location:       https://github.com/haskell-suite/haskell-src-exts.git++Test-Suite test+  type:                exitcode-stdio-1.0+  main-is:             Test/Runner.hs+  GHC-Options:         -threaded+  Default-language:    Haskell2010+  Build-depends:       base < 5,+                       haskell-src-exts,+                       smallcheck >= 1.0,+                       tasty,+                       tasty-smallcheck,+                       tasty-hunit,+                       filepath,+                       directory
src/Language/Haskell/Exts.hs view
@@ -76,25 +76,28 @@  -- | Parse a source file from a string using a custom parse mode. parseFileContentsWithMode :: ParseMode -> String -> ParseResult Module-parseFileContentsWithMode p@(ParseMode fn exts ign _ _) rawStr =+parseFileContentsWithMode p@(ParseMode fn oldLang exts ign _ _) rawStr =         let md = delit fn $ ppContents rawStr-            allExts = -- impliesExts $ -                            case (ign, readExtensions md) of-                                     (False,Just es) -> exts ++ es-                                     _               -> exts-         in parseWithMode (p { extensions = allExts }) md+            (bLang, extraExts) = +                case (ign, readExtensions md) of+                  (False, Just (mLang, es)) -> +                       (case mLang of {Nothing -> oldLang;Just newLang -> newLang}, es)+                  _ -> (oldLang, [])+         in parseWithMode (p { baseLanguage = bLang, extensions = exts ++ extraExts }) md  -- | Parse a source file from a string using a custom parse mode and retaining comments. parseFileContentsWithComments :: ParseMode -> String -> ParseResult (Module, [Comment])-parseFileContentsWithComments p@(ParseMode fn exts ign _ _) rawStr =+parseFileContentsWithComments p@(ParseMode fn oldLang exts ign _ _) rawStr =         let md = delit fn $ ppContents rawStr-            allExts = impliesExts $ case (ign, readExtensions md) of-                                     (False,Just es) -> exts ++ es-                                     _               -> exts-         in parseWithComments (p { extensions = allExts }) md+            (bLang, extraExts) = +                case (ign, readExtensions md) of+                  (False, Just (mLang, es)) -> +                       (case mLang of {Nothing -> oldLang;Just newLang -> newLang}, es)+                  _ -> (oldLang, [])+         in parseWithComments (p { baseLanguage = bLang, extensions = exts ++ extraExts }) md  --- | Gather the extensions declared in LANGUAGE pragmas+{-- | Gather the extensions declared in LANGUAGE pragmas --   at the top of the file. Returns 'Nothing' if the --   parse of the pragmas fails. readExtensions :: String -> Maybe [Extension]@@ -105,7 +108,32 @@         getExts (LanguagePragma _ ns) = map readExt ns         getExts _ = [] -        readExt (Ident e) = classifyExtension e+        readExt (Ident e) = classifyExtension e -}++-- | Gather the extensions declared in LANGUAGE pragmas+--   at the top of the file. Returns 'Nothing' if the+--   parse of the pragmas fails.+readExtensions :: String -> Maybe (Maybe Language, [Extension])+readExtensions str = case getTopPragmas str of+        ParseOk pgms -> extractLang $ concatMap getExts pgms+        _            -> Nothing+  where getExts :: ModulePragma -> [Either Language Extension]+        getExts (LanguagePragma _ ns) = map readExt ns+        getExts _ = []++        readExt (Ident e) = +            case classifyLanguage e of+              UnknownLanguage _ -> Right $ classifyExtension e+              lang -> Left lang++        extractLang = extractLang' Nothing []++        extractLang' lacc eacc [] = Just (lacc, eacc)+        extractLang' Nothing eacc (Left l : rest) = extractLang' (Just l) eacc rest+        extractLang' (Just l1) eacc (Left l2:rest)+            | l1 == l2  = extractLang' (Just l1) eacc rest+            | otherwise = Nothing+        extractLang' lacc eacc (Right ext : rest) = extractLang' lacc (ext:eacc) rest  ppContents :: String -> String ppContents = unlines . f . lines
src/Language/Haskell/Exts/Annotated.hs view
@@ -68,7 +68,10 @@ -- | Parse a source file on disk, with an extra set of extensions to know about --   on top of what the file itself declares. parseFileWithExts :: [Extension] -> FilePath -> IO (ParseResult (Module SrcSpanInfo))-parseFileWithExts exts fp = parseFileWithMode (defaultParseMode { extensions = exts, parseFilename = fp }) fp+parseFileWithExts exts fp = +    parseFileWithMode (defaultParseMode { +                         extensions = exts, +                         parseFilename = fp }) fp  -- | Parse a source file on disk, supplying a custom parse mode. parseFileWithMode :: ParseMode -> FilePath -> IO (ParseResult (Module SrcSpanInfo))@@ -84,38 +87,55 @@ -- | Parse a source file from a string, with an extra set of extensions to know about --   on top of what the file itself declares. parseFileContentsWithExts :: [Extension] -> String -> ParseResult (Module SrcSpanInfo)-parseFileContentsWithExts exts = parseFileContentsWithMode (defaultParseMode { extensions = exts })+parseFileContentsWithExts exts = +    parseFileContentsWithMode (defaultParseMode { extensions = exts })  -- | Parse a source file from a string using a custom parse mode. parseFileContentsWithMode :: ParseMode -> String -> ParseResult (Module SrcSpanInfo)-parseFileContentsWithMode p@(ParseMode fn exts ign _ _) rawStr =+parseFileContentsWithMode p@(ParseMode fn oldLang exts ign _ _) rawStr =         let md = delit fn $ ppContents rawStr-            allExts = -- impliesExts $ -                            case (ign, readExtensions md) of-                                     (False,Just es) -> exts ++ es-                                     _               -> exts-         in parseModuleWithMode (p { extensions = allExts }) md+            (bLang, extraExts) = +                case (ign, readExtensions md) of+                  (False, Just (mLang, es)) -> +                       (case mLang of {Nothing -> oldLang;Just newLang -> newLang}, es)+                  _ -> (oldLang, [])+         in -- trace (fn ++ ": " ++ show extraExts) $+              parseModuleWithMode (p { baseLanguage = bLang, extensions = exts ++ extraExts }) md  parseFileContentsWithComments :: ParseMode -> String -> ParseResult (Module SrcSpanInfo, [Comment])-parseFileContentsWithComments p@(ParseMode fn exts ign _ _) rawStr =+parseFileContentsWithComments p@(ParseMode fn oldLang exts ign _ _) rawStr =         let md = delit fn $ ppContents rawStr-            allExts = impliesExts $ case (ign, readExtensions md) of-                                     (False,Just es) -> exts ++ es-                                     _               -> exts-         in parseModuleWithComments (p { extensions = allExts }) md+            (bLang, extraExts) = +                case (ign, readExtensions md) of+                  (False, Just (mLang, es)) -> +                       (case mLang of {Nothing -> oldLang;Just newLang -> newLang}, es)+                  _ -> (oldLang, [])+         in parseModuleWithComments (p { baseLanguage = bLang, extensions = exts ++ extraExts }) md  -- | Gather the extensions declared in LANGUAGE pragmas --   at the top of the file. Returns 'Nothing' if the --   parse of the pragmas fails.-readExtensions :: String -> Maybe [Extension]+readExtensions :: String -> Maybe (Maybe Language, [Extension]) readExtensions str = case getTopPragmas str of-        ParseOk pgms -> Just (concatMap getExts pgms)+        ParseOk pgms -> extractLang $ concatMap getExts pgms         _            -> Nothing-  where getExts :: ModulePragma l -> [Extension]+  where getExts :: ModulePragma l -> [Either Language Extension]         getExts (LanguagePragma _ ns) = map readExt ns         getExts _ = [] -        readExt (Ident _ e) = classifyExtension e+        readExt (Ident _ e) = +            case classifyLanguage e of+              UnknownLanguage _ -> Right $ classifyExtension e+              lang -> Left lang++        extractLang = extractLang' Nothing []++        extractLang' lacc eacc [] = Just (lacc, eacc)+        extractLang' Nothing eacc (Left l : rest) = extractLang' (Just l) eacc rest+        extractLang' (Just l1) eacc (Left l2:rest)+            | l1 == l2  = extractLang' (Just l1) eacc rest+            | otherwise = Nothing+        extractLang' lacc eacc (Right ext : rest) = extractLang' lacc (ext:eacc) rest  ppContents :: String -> String ppContents = unlines . f . lines
src/Language/Haskell/Exts/Annotated/Build.hs view
@@ -120,11 +120,11 @@  -- | A tuple expression. tuple :: l -> [Exp l] -> Exp l-tuple = Tuple+tuple l = Tuple l Boxed  -- | A tuple pattern. pTuple :: l -> [Pat l] -> Pat l-pTuple = PTuple+pTuple l = PTuple l Boxed  -- | A tuple expression consisting of variables only. varTuple :: l -> [Name l] -> Exp l
src/Language/Haskell/Exts/Annotated/ExactPrint.hs view
@@ -1,1794 +1,1803 @@------------------------------------------------------------------------------
--- |
--- Module      :  Language.Haskell.Exts.Annotated.ExactPrint
--- Copyright   :  (c) Niklas Broberg 2009
--- License     :  BSD-style (see the file LICENSE.txt)
---
--- Maintainer  :  Niklas Broberg, d00nibro@chalmers.se
--- Stability   :  stable
--- Portability :  portable
---
--- Exact-printer for Haskell abstract syntax. The input is a (semi-concrete)
--- abstract syntax tree, annotated with exact source information to enable
--- printing the tree exactly as it was parsed.
---
------------------------------------------------------------------------------
-module Language.Haskell.Exts.Annotated.ExactPrint
-        ( exactPrint
-        , ExactP
-        ) where
-
-import Language.Haskell.Exts.Annotated.Syntax
-import Language.Haskell.Exts.SrcLoc
-import Language.Haskell.Exts.Comments
-
-import Control.Monad (when)
-import Control.Arrow ((***), (&&&))
-import Data.List (intersperse)
-
--- import Debug.Trace (trace)
-
-------------------------------------------------------
--- The EP monad and basic combinators
-
-type Pos = (Int,Int)
-
-pos :: (SrcInfo loc) => loc -> Pos
-pos ss = (startLine ss, startColumn ss)
-
-newtype EP x = EP (Pos -> [Comment] -> (x, Pos, [Comment], ShowS))
-
-instance Monad EP where
-  return x = EP $ \l cs -> (x, l, cs, id)
-
-  EP m >>= k = EP $ \l0 c0 -> let
-        (a, l1, c1, s1) = m l0 c0
-        EP f = k a
-        (b, l2, c2, s2) = f l1 c1
-    in (b, l2, c2, s1 . s2)
-
-runEP :: EP () -> [Comment] -> String
-runEP (EP f) cs = let (_,_,_,s) = f (1,1) cs in s ""
-
-getPos :: EP Pos
-getPos = EP (\l cs -> (l,l,cs,id))
-
-setPos :: Pos -> EP ()
-setPos l = EP (\_ cs -> ((),l,cs,id))
-
-printString :: String -> EP ()
-printString str = EP (\(l,c) cs -> ((), (l,c+length str), cs, showString str))
-
-getComment :: EP (Maybe Comment)
-getComment = EP $ \l cs ->
-    let x = case cs of
-             c:_ -> Just c
-             _   -> Nothing
-     in (x, l, cs, id)
-
-dropComment :: EP ()
-dropComment = EP $ \l cs ->
-    let cs' = case cs of
-               (_:cs) -> cs
-               _      -> cs
-     in ((), l, cs', id)
-
-newLine :: EP ()
-newLine = do
-    (l,_) <- getPos
-    printString "\n"
-    setPos (l+1,1)
-
-padUntil :: Pos -> EP ()
-padUntil (l,c) = do
-    (l1,c1) <- getPos
-    case  {- trace (show ((l,c), (l1,c1))) -} () of
-     _ {-()-} | l1 >= l && c1 <= c -> printString $ replicate (c - c1) ' '
-              | l1 < l             -> newLine >> padUntil (l,c)
-              | otherwise          -> return ()
-
-
-mPrintComments :: Pos -> EP ()
-mPrintComments p = do
-    mc <- getComment
-    case mc of
-     Nothing -> return ()
-     Just (Comment multi s str) ->
-        when (pos s < p) $ do
-            dropComment
-            padUntil (pos s)
-            printComment multi str
-            setPos (srcSpanEndLine s, srcSpanEndColumn s)
-            mPrintComments p
-
-printComment :: Bool -> String -> EP ()
-printComment b str
-    | b         = printString $ "{-" ++ str ++ "-}"
-    | otherwise = printString $ "--" ++ str
-
-printWhitespace :: Pos -> EP ()
-printWhitespace p = mPrintComments p >> padUntil p
-
-printStringAt :: Pos -> String -> EP ()
-printStringAt p str = printWhitespace p >> printString str
-
-errorEP :: String -> EP a
-errorEP = fail
-
-------------------------------------------------------------------------------
--- Printing of source elements
-
--- | Print an AST exactly as specified by the annotations on the nodes in the tree.
-exactPrint :: (ExactP ast) => ast SrcSpanInfo -> [Comment] -> String
-exactPrint ast cs = runEP (exactPC ast) cs
-
-exactPC :: (ExactP ast) => ast SrcSpanInfo -> EP ()
-exactPC ast = let p = pos (ann ast) in mPrintComments p >> padUntil p >> exactP ast
-
-printSeq :: [(Pos, EP ())] -> EP ()
-printSeq [] = return ()
-printSeq ((p,pr):xs) = printWhitespace p >> pr >> printSeq xs
-
-printStrs :: SrcInfo loc => [(loc, String)] -> EP ()
-printStrs = printSeq . map (pos *** printString)
-
-printPoints :: SrcSpanInfo -> [String] -> EP ()
-printPoints l = printStrs . zip (srcInfoPoints l)
-
-printInterleaved, printInterleaved' :: (Annotated ast, ExactP ast, SrcInfo loc) => [(loc, String)] -> [ast SrcSpanInfo] -> EP ()
-printInterleaved sistrs asts = printSeq $
-    interleave (map (pos *** printString ) sistrs)
-               (map (pos . ann &&& exactP) asts)
-
-printInterleaved' sistrs (a:asts) = exactPC a >> printInterleaved sistrs asts
-
-printStreams :: [(Pos, EP ())] -> [(Pos, EP ())] -> EP ()
-printStreams [] ys = printSeq ys
-printStreams xs [] = printSeq xs
-printStreams (x@(p1,ep1):xs) (y@(p2,ep2):ys)
-    | p1 <= p2 = printWhitespace p1 >> ep1 >> printStreams xs (y:ys)
-    | otherwise = printWhitespace p2 >> ep2 >> printStreams (x:xs) ys
-
-
-interleave :: [a] -> [a] -> [a]
-interleave [] ys = ys
-interleave xs [] = xs
-interleave (x:xs) (y:ys) = x:y: interleave xs ys
-
-maybeEP :: (a -> EP ()) -> Maybe a -> EP ()
-maybeEP = maybe (return ())
-
-bracketList :: (Annotated ast, ExactP ast) => (String, String, String) -> [SrcSpan] -> [ast SrcSpanInfo] -> EP ()
-bracketList (a,b,c) poss asts = printInterleaved (pList poss (a,b,c)) asts
-
-pList (p:ps) (a,b,c) = (p,a) : pList' ps (b,c)
-pList' [] _ = []
-pList' [p] (_,c) = [(p,c)]
-pList' (p:ps) (b,c) = (p, b) : pList' ps (b,c)
-
-parenList, squareList, curlyList :: (Annotated ast, ExactP ast) => [SrcSpan] -> [ast SrcSpanInfo] -> EP ()
-parenList = bracketList ("(",",",")")
-squareList = bracketList ("[",",","]")
-curlyList = bracketList ("{",",","}")
-
-layoutList :: (Functor ast, Show (ast ()), Annotated ast, ExactP ast) => [SrcSpan] -> [ast SrcSpanInfo] -> EP ()
-layoutList poss asts = printStreams 
-        (map (pos *** printString) $ lList poss) 
-        (map (pos . ann &&& exactP) asts)
-
-lList (p:ps) = (if isNullSpan p then (p,"") else (p,"{")) : lList' ps
-lList' [] = []
-lList' [p] = [if isNullSpan p then (p,"") else (p,"}")]
-lList' (p:ps) = (if isNullSpan p then (p,"") else (p,";")) : lList' ps
-
-printSemi :: SrcSpan -> EP ()
-printSemi p = do
-  printWhitespace (pos p)
-  when (not $ isNullSpan p) $ printString ";"
-                
-
---------------------------------------------------
--- Exact printing
-
-class Annotated ast => ExactP ast where
-  exactP :: ast SrcSpanInfo -> EP ()
-
-instance ExactP Literal where
-  exactP lit = case lit of
-    Char       _ _ rw -> printString ('\'':rw ++ "\'")
-    String     _ _ rw -> printString ('\"':rw ++ "\"")
-    Int        _ _ rw -> printString (rw)
-    Frac       _ _ rw -> printString (rw)
-    PrimInt    _ _ rw -> printString (rw ++ "#" )
-    PrimWord   _ _ rw -> printString (rw ++ "##")
-    PrimFloat  _ _ rw -> printString (rw ++ "#" )
-    PrimDouble _ _ rw -> printString (rw ++ "##")
-    PrimChar   _ _ rw -> printString ('\'':rw ++ "\'#" )
-    PrimString _ _ rw -> printString ('\"':rw ++ "\"#" )
-
-instance ExactP ModuleName where
-  exactP (ModuleName l str) = printString str
-
-instance ExactP SpecialCon where
-  exactP sc = case sc of
-    UnitCon l   -> printPoints l ["(",")"]
-    ListCon l   -> printPoints l ["[","]"]
-    FunCon  l   -> printPoints l ["(","->",")"]
-    TupleCon l b n -> printPoints l $
-        case b of
-         Unboxed -> "(#": replicate (n-1) "," ++ ["#)"]
-         _       -> "(" : replicate (n-1) "," ++ [")"]
-    Cons l      -> printString ":"
-    UnboxedSingleCon l -> printPoints l ["(#","#)"]
-
-isSymbol :: Name l -> Bool
-isSymbol (Symbol _ _) = True
-isSymbol _ = False
-
-getName :: QName l -> Name l
-getName (UnQual _ s) = s
-getName (Qual _ _ s) = s
-getName (Special l (Cons _)) = Symbol l ":"
-getName (Special l (FunCon _)) = Symbol l "->"
-getName (Special l s) = Ident l (specialName s)
-
-specialName :: SpecialCon l -> String
-specialName (UnitCon _) = "()"
-specialName (ListCon _) = "[]"
-specialName (FunCon  _) = "->"
-specialName (TupleCon _ b n) = "(" ++ hash ++ replicate (n-1) ',' ++ hash ++ ")"
-    where hash = case b of
-                   Unboxed -> "#"
-                   _       -> ""
-specialName (Cons _) = ":"
-
-instance ExactP QName where
-  exactP qn
-    | isSymbol (getName qn) = do
-        case srcInfoPoints (ann qn) of
-         [a,b,c] -> do
-            printString "("
-            printWhitespace (pos b)
-            epQName qn
-            printStringAt (pos c) ")"
-         _ -> errorEP "ExactP: QName is given wrong number of srcInfoPoints"
-    | otherwise = epQName qn
-
-epQName :: QName SrcSpanInfo -> EP ()
-epQName qn = case qn of
-    Qual    l mn n  -> exactP mn >> printString "." >> epName n
-    UnQual  l    n  -> epName n
-    Special l sc    -> exactP sc
-
-epInfixQName :: QName SrcSpanInfo -> EP ()
-epInfixQName qn
-    | isSymbol (getName qn) = printWhitespace (pos (ann qn)) >> epQName qn
-    | otherwise = do
-        case srcInfoPoints (ann qn) of
-         [a,b,c] -> do
-            printStringAt (pos a) "`"
-            printWhitespace (pos b)
-            epQName qn
-            printStringAt (pos c) "`"
-         _ -> errorEP "ExactP: QName (epInfixName) is given wrong number of srcInfoPoints"
-
-instance ExactP Name where
-  exactP n = case n of
-    Ident  l str    -> printString str
-    Symbol l str    -> do
-        case srcInfoPoints l of
-         [a,b,c] -> do
-            printString "("
-            printWhitespace (pos b)
-            printString str
-            printStringAt (pos c) ")"
-         _ -> errorEP "ExactP: Name is given wrong number of srcInfoPoints"
-
-epName :: Name SrcSpanInfo -> EP ()
-epName (Ident  _ str) = printString str
-epName (Symbol _ str) = printString str
-
-epInfixName :: Name SrcSpanInfo -> EP ()
-epInfixName n
-    | isSymbol n = printWhitespace (pos (ann n)) >> epName n
-    | otherwise = do
-        case srcInfoPoints (ann n) of
-         [a,b,c] -> do
-            printStringAt (pos a) "`"
-            printWhitespace (pos b)
-            epName n
-            printStringAt (pos c) "`"
-         _ -> errorEP "ExactP: Name (epInfixName) is given wrong number of srcInfoPoints"
-
-instance ExactP IPName where
-  exactP ipn = case ipn of
-    IPDup l str -> printString $ '?':str
-    IPLin l str -> printString $ '%':str
-
-instance ExactP QOp where
-  exactP qop = case qop of
-    QVarOp l qn -> epInfixQName qn
-    QConOp l qn -> epInfixQName qn
-
-instance ExactP Op where
-  exactP op = case op of
-    VarOp l n -> epInfixName n
-    ConOp l n -> epInfixName n
-
-
-
-instance ExactP CName where
-  exactP cn = case cn of
-    VarName l n -> exactP n
-    ConName l n -> exactP n
-
-instance ExactP ExportSpec where
-  exactP espec = case espec of
-     EVar l qn      -> exactP qn
-     EAbs l qn      -> exactP qn
-     EThingAll l qn -> exactP qn >> printPoints l ["(","..",")"]
-     EThingWith l qn cns    ->
-        let k = length (srcInfoPoints l)
-         in exactP qn >> printInterleaved (zip (srcInfoPoints l) $ "(":replicate (k-2) "," ++ [")"]) cns
-     EModuleContents l mn -> printString "module" >> exactPC mn
-
-instance ExactP ExportSpecList where
-  exactP (ExportSpecList l ess) =
-    let k = length (srcInfoPoints l)
-     in printInterleaved (zip (srcInfoPoints l) $ "(": replicate (k-2) "," ++ [")"]) ess
-
-instance ExactP ImportSpecList where
-  exactP (ImportSpecList l hid ispecs) = do
-    let pts = srcInfoPoints l
-    pts <- if hid then do
-             let (x:pts') = pts
-             printStringAt (pos x) "hiding"
-             return pts'
-            else return pts
-    let k = length pts
-    printInterleaved (zip pts $ "(": replicate (k-2) "," ++ [")"]) ispecs
-
-instance ExactP ImportSpec where
-  exactP ispec = case ispec of
-    IVar l n    -> exactP n
-    IAbs l n    -> exactP n
-    IThingAll l n   -> exactP n >> printPoints l ["(","..",")"]
-    IThingWith l n cns    ->
-        let k = length (srcInfoPoints l)
-         in exactP n >> printInterleaved (zip (srcInfoPoints l) $ "(":replicate (k-2) "," ++ [")"]) cns
-
-instance ExactP ImportDecl where
-  exactP (ImportDecl l mn qf src mpkg mas mispecs) = do
-    printString "import"
-    case srcInfoPoints l of
-     (a:pts) -> do
-        pts <- if src then
-                 case pts of
-                  x:y:pts' -> do
-                     printStringAt (pos x) "{-# SOURCE"
-                     printStringAt (pos y) "#-}"
-                     return pts'
-                  _ -> errorEP "ExactP: ImportDecl is given too few srcInfoPoints"
-                else return pts
-        pts <- if qf then
-                 case pts of
-                  x:pts' -> do
-                     printStringAt (pos x) "qualified"
-                     return pts'
-                  _ -> errorEP "ExactP: ImportDecl is given too few srcInfoPoints"
-                else return pts
-        pts <- case mpkg of
-                Just pkg ->
-                  case pts of
-                   x:pts' -> do
-                      printStringAt (pos x) $ show pkg
-                      return pts'
-                   _ -> errorEP "ExactP: ImportDecl is given too few srcInfoPoints"
-                _ -> return pts
-        exactPC mn
-        pts <- case mas of
-                Just as ->
-                 case pts of
-                  x:pts' -> do
-                     printStringAt (pos x) "as"
-                     exactPC as
-                     return pts'
-                  _ -> errorEP "ExactP: ImportDecl is given too few srcInfoPoints"
-                _ -> return pts
-        case mispecs of
-         Nothing -> return ()
-         Just ispecs -> exactPC ispecs
-     _ -> errorEP "ExactP: ImportDecl is given too few srcInfoPoints"
-
-instance ExactP Module where
-  exactP mdl = case mdl of
-    Module l mmh oss ids decls -> do
-        let (oPts, pts) = splitAt (max (length oss + 1) 2) (srcInfoPoints l)
-        layoutList oPts oss
-        maybeEP exactPC mmh
-        printStreams (map (pos *** printString) $ lList pts)
-                     (map (pos . ann &&& exactPC) ids ++ map (pos . ann &&& exactPC) (sepFunBinds decls))
-    XmlPage l _mn oss xn attrs mat es  -> do
-        let (oPts, pPts) = splitAt (max (length oss + 1) 2) $ srcInfoPoints l
-        case pPts of
-         [a,b,c,d,e] -> do
-            layoutList oPts oss
-            printStringAt (pos a) "<"
-            exactPC xn
-            mapM_ exactPC attrs
-            maybeEP exactPC mat
-            printStringAt (pos b) ">"
-            mapM_ exactPC es
-            printStringAt (pos c) "</"
-            printWhitespace (pos d)
-            exactP xn
-            printStringAt (pos e) ">"
-         _ -> errorEP "ExactP: Module: XmlPage is given wrong number of srcInfoPoints"
-    XmlHybrid l mmh oss ids decls xn attrs mat es -> do
-        let (oPts, pts) = splitAt (max (length oss + 1) 2) (srcInfoPoints l)
-        layoutList oPts oss
-        maybeEP exactPC mmh
-        let (dPts, pPts) = splitAt (length pts - 5) pts
-        case pPts of
-         [a,b,c,d,e] -> do
-            printStreams (map (\(p,s) -> (pos p, printString s)) $ lList dPts)
-                         (map (\i -> (pos $ ann i, exactPC i)) ids ++ map (\d -> (pos $ ann d, exactPC d)) (sepFunBinds decls))
-    
-            printStringAt (pos a) "<"
-            exactPC xn
-            mapM_ exactPC attrs
-            maybeEP exactPC mat
-            printStringAt (pos b) ">"
-            mapM_ exactPC es
-            printStringAt (pos c) "</"
-            printWhitespace (pos d)
-            exactP xn
-            printStringAt (pos e) ">"
-         _ -> errorEP "ExactP: Module: XmlHybrid is given wrong number of srcInfoPoints"
-
-instance ExactP ModuleHead where
-  exactP (ModuleHead l mn mwt mess) = do
-    case srcInfoPoints l of
-     [a,b] -> do
-        printStringAt (pos a) "module"
-        exactPC mn
-        maybeEP exactPC mwt
-        maybeEP exactPC mess
-        printStringAt (pos b) "where"
-     _ -> errorEP "ExactP: ModuleHead is given wrong number of srcInfoPoints"
-
-instance ExactP ModulePragma where
-  exactP op = case op of
-    LanguagePragma   l ns       ->
-        let pts = srcInfoPoints l
-            k = length ns - 1 -- number of commas
-            m = length pts - k - 2 -- number of virtual semis, likely 0
-         in printInterleaved (zip pts ("{-# LANGUAGE":replicate k "," ++ replicate m "" ++ ["#-}"])) ns
-    OptionsPragma    l mt str   ->
-        let k = length (srcInfoPoints l)
-            opstr = "{-# OPTIONS" ++ case mt of { Just t -> "_" ++ show t ; _ -> "" } ++ " " ++ str
-         in printPoints l $ opstr : replicate (k-2) "" ++ ["#-}"]
-    AnnModulePragma  l ann       ->
-        case srcInfoPoints l of
-         [a,b] -> do
-            printString $ "{-# ANN"
-            exactPC ann
-            printStringAt (pos b) "#-}"
-         _ -> errorEP "ExactP: ModulePragma: AnnPragma is given wrong number of srcInfoPoints"
-
-instance ExactP WarningText where
-    exactP (DeprText l str) = printPoints l ["{-# DEPRECATED", str, "#-}"]
-    exactP (WarnText l str) = printPoints l ["{-# WARNING",    str, "#-}"]
-
-instance ExactP Assoc where
-  exactP a = case a of
-    AssocNone  l -> printString "infix"
-    AssocLeft  l -> printString "infixl"
-    AssocRight l -> printString "infixr"
-
-instance ExactP DataOrNew where
-  exactP (DataType l) = printString "data"
-  exactP (NewType  l) = printString "newtype"
-
-instance ExactP Decl where
-  exactP decl = case decl of
-    TypeDecl     l dh t      ->
-        case srcInfoPoints l of
-         [a,b] -> do
-            printStringAt (pos a) "type"
-            exactPC dh
-            printStringAt (pos b) "="
-            exactPC t
-         _ -> errorEP "ExactP: Decl: TypeDecl is given wrong number of srcInfoPoints"
-    TypeFamDecl  l dh mk     ->
-        case srcInfoPoints l of
-         a:b:ps -> do
-            printStringAt (pos a) "type"
-            printStringAt (pos b) "family"
-            exactPC dh
-            maybeEP (\k -> printStringAt (pos (head ps)) "::" >> exactPC k) mk
-         _ -> errorEP "ExactP: Decl: TypeFamDecl is given wrong number of srcInfoPoints"
-    DataDecl     l dn mctxt dh constrs mder -> do
-        exactP dn
-        maybeEP exactPC mctxt
-        exactPC dh
-        -- the next line works for empty data types since the srcInfoPoints will be empty then
-        printInterleaved (zip (srcInfoPoints l) ("=": repeat "|")) constrs
-        maybeEP exactPC mder
-    GDataDecl    l dn mctxt dh mk gds mder -> do
-        let pts = srcInfoPoints l
-        exactP dn
-        maybeEP exactPC mctxt
-        exactPC dh
-        pts <- case mk of
-                Nothing -> return pts
-                Just kd -> case pts of 
-                            p:pts' -> do
-                               printStringAt (pos p) "::"
-                               exactPC kd
-                               return pts'
-                            _ -> errorEP "ExactP: Decl: GDataDecl is given too few srcInfoPoints"
-        case pts of
-         x:pts -> do
-            printStringAt (pos x) "where"
-            layoutList pts gds
-            maybeEP exactPC mder
-         _ -> errorEP "ExactP: Decl: GDataDecl is given too few srcInfoPoints"
-    DataFamDecl  l mctxt dh mk -> do
-        printString "data"
-        maybeEP exactPC mctxt
-        exactPC dh
-        maybeEP (\kd -> printStringAt (pos (head (srcInfoPoints l))) "::" >> exactPC kd) mk
-    TypeInsDecl  l t1 t2 ->
-        case srcInfoPoints l of
-         [a,b,c] -> do
-            printString "type"
-            printStringAt (pos b) "instance"
-            exactPC t1
-            printStringAt (pos c) "="
-            exactPC t2
-         _ -> errorEP "ExactP: Decl: TypeInsDecl is given wrong number of srcInfoPoints"
-    DataInsDecl  l dn t constrs mder    ->
-        case srcInfoPoints l of
-         p:pts -> do
-            exactP dn
-            printStringAt (pos p) "instance"
-            exactPC t
-            printInterleaved (zip pts ("=": repeat "|")) constrs
-            maybeEP exactPC mder
-         _ -> errorEP "ExactP: Decl: DataInsDecl is given too few srcInfoPoints"
-    GDataInsDecl l dn t mk gds mder     ->
-        case srcInfoPoints l of
-         p:pts -> do
-            exactP dn
-            printStringAt (pos p) "instance"
-            exactPC t
-            pts <- case mk of
-                    Nothing -> return pts
-                    Just kd -> case pts of
-                                p:pts' -> do
-                                    printStringAt (pos p) "::"
-                                    exactPC kd
-                                    return pts'
-                                _ -> errorEP "ExactP: Decl: GDataInsDecl is given too few srcInfoPoints"
-            case pts of
-             x:pts -> do
-                printStringAt (pos x) "where"
-                layoutList pts gds
-                maybeEP exactPC mder
-             _ -> errorEP "ExactP: Decl: GDataInsDecl is given too few srcInfoPoints" 
-         _ -> errorEP "ExactP: Decl: GDataInsDecl is given too few srcInfoPoints"
-    ClassDecl    l mctxt dh fds mcds    ->
-        case srcInfoPoints l of
-         a:pts -> do
-            printString "class"
-            maybeEP exactPC mctxt
-            exactPC dh
-            pts <- case fds of
-                    [] -> return pts
-                    _  -> do
-                      let (pts1, pts2) = splitAt (length fds) pts
-                      printInterleaved (zip pts1 ("|":repeat ",")) fds
-                      return pts2
-            maybeEP (\cds ->
-                case pts of
-                 p:pts' -> do
-                    printStringAt (pos p) "where"
-                    layoutList pts' $ sepClassFunBinds cds
-                 _ -> errorEP "ExactP: Decl: ClassDecl is given too few srcInfoPoints"
-                ) mcds                
-         _ -> errorEP "ExactP: Decl: ClassDecl is given too few srcInfoPoints"
-    InstDecl     l mctxt ih mids        ->
-        case srcInfoPoints l of
-         a:pts -> do
-            printString "instance"
-            maybeEP exactPC mctxt
-            exactPC ih
-            maybeEP (\ids -> do
-                let (p:pts') = pts
-                printStringAt (pos p) "where"
-                layoutList pts' $ sepInstFunBinds ids
-                ) mids
-         _ -> errorEP "ExactP: Decl: InstDecl is given too few srcInfoPoints"
-    DerivDecl    l mctxt ih             ->
-        case srcInfoPoints l of
-         [a,b] -> do
-            printString "deriving"
-            printStringAt (pos b) "instance"
-            maybeEP exactPC mctxt
-            exactPC ih
-         _ -> errorEP "ExactP: Decl: DerivDecl is given wrong number of srcInfoPoints"
-    InfixDecl    l assoc mprec ops      -> do
-        let pts = srcInfoPoints l
-        exactP assoc
-        pts <- case mprec of
-                Nothing -> return pts
-                Just prec ->
-                    case pts of
-                     p:pts' -> do
-                        printStringAt (pos p) (show prec)
-                        return pts'
-                     _ -> errorEP "ExactP: Decl: InfixDecl is given too few srcInfoPoints"
-        printInterleaved' (zip pts (repeat ",")) ops
-    DefaultDecl  l ts   ->
-        case srcInfoPoints l of
-         a:pts -> do
-            printString "default"
-            printInterleaved (zip (init pts) ("(":repeat ",")) ts
-            printStringAt (pos (last pts)) ")"
-         _ -> errorEP "ExactP: Decl: DefaultDecl is given too few srcInfoPoints"
-    SpliceDecl   l spl  -> exactP spl
-    TypeSig      l ns t -> do
-        let pts = srcInfoPoints l
-        printInterleaved' (zip pts (replicate (length pts - 1) "," ++ ["::"])) ns
-        exactPC t
-    FunBind      l ms   -> mapM_ exactPC ms
-    PatBind      l p mt rhs mbs -> do
-        let pts = srcInfoPoints l
-        exactP p
-        pts <- case mt of
-                Nothing -> return pts
-                Just t  -> case pts of
-                            x:pts'-> do
-                                printStringAt (pos x) "::"
-                                exactPC t
-                                return pts'
-                            _ -> errorEP "ExactP: Decl: PatBind is given too few srcInfoPoints"
-        exactPC rhs
-        maybeEP (\bs -> printStringAt (pos (head pts)) "where" >> exactPC bs) mbs
-    ForImp       l cc msf mstr n t   ->
-        case srcInfoPoints l of
-         a:b:pts -> do
-            printString "foreign"
-            printStringAt (pos b) "import"
-            exactPC cc
-            maybeEP exactPC msf
-            pts <- case mstr of
-                      Nothing -> return pts
-                      Just str -> case pts of 
-                                   x:pts' -> do
-                                      printStringAt (pos x) (show str)
-                                      return pts'
-                                   _ -> errorEP "ExactP: Decl: ForImp is given too few srcInfoPoints"
-            case pts of
-             y:_ -> do
-                exactPC n
-                printStringAt (pos y) "::"
-                exactPC t
-             _ -> errorEP "ExactP: Decl: ForImp is given too few srcInfoPoints"
-         _ -> errorEP "ExactP: Decl: ForImp is given too few srcInfoPoints"
-    ForExp       l cc mstr n t      ->
-        case srcInfoPoints l of
-         a:b:pts -> do
-            printString "foreign"
-            printStringAt (pos b) "export"
-            exactPC cc
-            pts <- case mstr of
-                      Nothing -> return pts
-                      Just str -> case pts of
-                                   x:pts' -> do
-                                      printStringAt (pos x) (show str)
-                                      return pts'
-                                   _ -> errorEP "ExactP: Decl: ForExp is given too few srcInfoPoints"
-            case pts of
-             y:_ -> do
-                exactPC n
-                printStringAt (pos y) "::"
-                exactPC t
-             _ -> errorEP "ExactP: Decl: ForExp is given too few srcInfoPoints"
-         _ -> errorEP "ExactP: Decl: ForExp is given too few srcInfoPoints"
-    RulePragmaDecl   l rs   ->
-        case srcInfoPoints l of
-         [a,b] -> do
-            printString "{-# RULES"
-            mapM_ exactPC rs
-            printStringAt (pos b) "#-}"
-         _ -> errorEP "ExactP: Decl: RulePragmaDecl is given too few srcInfoPoints"
-    DeprPragmaDecl   l nstrs ->
-        case srcInfoPoints l of
-         a:pts -> do
-            printString "{-# DEPRECATED"
-            printWarndeprs (map pos (init pts)) nstrs
-            printStringAt (pos (last pts)) "#-}"
-         _ -> errorEP "ExactP: Decl: DeprPragmaDecl is given too few srcInfoPoints"
-    WarnPragmaDecl   l nstrs ->
-        case srcInfoPoints l of
-         a:pts -> do
-            printString "{-# WARNING"
-            printWarndeprs (map pos (init pts)) nstrs
-            printStringAt (pos (last pts)) "#-}"
-         _ -> errorEP "ExactP: Decl: WarnPragmaDecl is given too few srcInfoPoints"
-    InlineSig        l inl mact qn    ->
-        case srcInfoPoints l of
-         [a,b] -> do
-            printString $ if inl then "{-# INLINE" else "{-# NOINLINE"
-            maybeEP exactPC mact
-            exactPC qn
-            printStringAt (pos b) "#-}"
-         _ -> errorEP "ExactP: Decl: InlineSig is given wrong number of srcInfoPoints"
-    InlineConlikeSig l mact qn    ->
-        case srcInfoPoints l of
-         [a,b] -> do
-            printString "{-# INLINE_CONLIKE"
-            maybeEP exactPC mact
-            exactPC qn
-            printStringAt (pos b) "#-}"
-         _ -> errorEP "ExactP: Decl: InlineConlikeSig is given wrong number of srcInfoPoints"
-    SpecSig          l qn ts        ->
-        case srcInfoPoints l of
-         a:pts -> do
-            printString "{-# SPECIALISE"
-            exactPC qn
-            printInterleaved (zip pts ("::" : repeat "," ++ ["#-}"])) ts
-         _ -> errorEP "ExactP: Decl: SpecSig is given too few srcInfoPoints"
-    SpecInlineSig    l b mact qn ts ->
-        case srcInfoPoints l of
-         a:pts -> do
-            printString $ "{-# SPECIALISE " ++ if b then "INLINE" else "NOINLINE"
-            maybeEP exactPC mact
-            exactPC qn
-            printInterleaved (zip pts ("::" : repeat "," ++ ["#-}"])) ts
-         _ -> errorEP "ExactP: Decl: SpecInlineSig is given too few srcInfoPoints"
-    InstSig          l mctxt ih     ->
-        case srcInfoPoints l of
-         [a,b,c] -> do
-            printString $ "{-# SPECIALISE"
-            printStringAt (pos b) "instance"
-            maybeEP exactPC mctxt
-            exactPC ih
-            printStringAt (pos c) "#-}"
-         _ -> errorEP "ExactP: Decl: InstSig is given wrong number of srcInfoPoints"
-    AnnPragma       l ann       ->
-        case srcInfoPoints l of
-         [a,b] -> do
-            printString $ "{-# ANN"
-            exactPC ann
-            printStringAt (pos b) "#-}"
-         _ -> errorEP "ExactP: Decl: AnnPragma is given wrong number of srcInfoPoints"
-
-
-instance ExactP Annotation where
-    exactP ann = case ann of
-        Ann     l n e   -> do
-            exactP n
-            exactPC e
-        TypeAnn l n e   -> do
-            printString "type"
-            exactPC n
-            exactPC e
-        ModuleAnn l e   -> do
-            printString "module"
-            exactPC e
-
-printWarndeprs :: [Pos] -> [([Name SrcSpanInfo], String)] -> EP ()
-printWarndeprs _ [] = return ()
-printWarndeprs ps ((ns,str):nsts) = printWd ps ns str nsts
-  where printWd :: [Pos] -> [Name SrcSpanInfo] -> String -> [([Name SrcSpanInfo], String)] -> EP ()
-        printWd (p:ps) []  str nsts = printStringAt p (show str) >> printWarndeprs ps nsts
-        printWd ps     [n] str nsts = exactPC n >> printWd ps [] str nsts
-        printWd (p:ps) (n:ns) str nsts = exactPC n >> printStringAt p "," >> printWd ps ns str nsts
-
-
-sepFunBinds :: [Decl SrcSpanInfo] -> [Decl SrcSpanInfo]
-sepFunBinds [] = []
-sepFunBinds (FunBind _ ms:ds) = map (\m -> FunBind (ann m) [m]) ms ++ sepFunBinds ds
-sepFunBinds (d:ds) = d : sepFunBinds ds
-
-sepClassFunBinds :: [ClassDecl SrcSpanInfo] -> [ClassDecl SrcSpanInfo]
-sepClassFunBinds [] = []
-sepClassFunBinds (ClsDecl _ (FunBind _ ms):ds) = map (\m -> ClsDecl (ann m) $ FunBind (ann m) [m]) ms ++ sepClassFunBinds ds
-sepClassFunBinds (d:ds) = d : sepClassFunBinds ds
-
-sepInstFunBinds :: [InstDecl SrcSpanInfo] -> [InstDecl SrcSpanInfo]
-sepInstFunBinds [] = []
-sepInstFunBinds (InsDecl _ (FunBind _ ms):ds) = map (\m -> InsDecl (ann m) $ FunBind (ann m) [m]) ms ++ sepInstFunBinds ds
-sepInstFunBinds (d:ds) = d : sepInstFunBinds ds
-
-instance ExactP DeclHead where
-  exactP dh = case dh of
-    DHead l n tvs       -> exactP n >> mapM_ exactPC tvs
-    DHInfix l tva n tvb -> exactP tva >> epInfixName n >> exactPC tvb
-    DHParen l dh        ->
-        case srcInfoPoints l of
-         [_,b] -> printString "(" >> exactPC dh >> printStringAt (pos b) ")"
-         _ -> errorEP "ExactP: DeclHead: DeclParen is given wrong number of srcInfoPoints"
-
-instance ExactP InstHead where
-  exactP ih = case ih of
-    IHead l qn ts       -> exactP qn >> mapM_ exactPC ts
-    IHInfix l ta qn tb  -> exactP ta >> epInfixQName qn >> exactPC tb
-    IHParen l ih        ->
-        case srcInfoPoints l of
-         [_,b] -> printString "(" >> exactPC ih >> printStringAt (pos b) ")"
-         _ -> errorEP "ExactP: InstHead: IHParen is given wrong number of srcInfoPoints"
-
-instance ExactP TyVarBind where
-  exactP (KindedVar   l n k) =
-        case srcInfoPoints l of
-         [a,b,c] -> do
-            printString "("
-            exactPC n
-            printStringAt (pos b) "::"
-            exactPC k
-            printStringAt (pos c) ")"
-         _ -> errorEP "ExactP: TyVarBind: KindedVar is given wrong number of srcInfoPoints"
-  exactP (UnkindedVar l n) = exactP n
-
-instance ExactP Kind where
-  exactP kd = case kd of
-    KindStar  l     -> printString "*"
-    KindBang  l     -> printString "!"
-    KindFn    l k1 k2 ->
-        case srcInfoPoints l of
-         [a] -> do
-            exactP k1
-            printStringAt (pos a) "->"
-            exactPC k2
-         _ -> errorEP "ExactP: Kind: KindFn is given wrong number of srcInfoPoints"
-    KindParen l kd  -> do
-        case srcInfoPoints l of
-         [a,b] -> do
-            printString "("
-            exactPC kd
-            printStringAt (pos b) ")"
-         _ -> errorEP "ExactP: Kind: KindParen is given wrong number of srcInfoPoints"
-    KindVar l n     -> exactP n       
-
-instance ExactP Type where
-  exactP t = case t of
-    TyForall l mtvs mctxt t -> do
-        let pts = srcInfoPoints l
-        pts <- case mtvs of
-                Nothing -> return pts
-                Just tvs ->
-                    case pts of
-                     a:b:pts' -> do
-                        printString "forall"
-                        mapM_ exactPC tvs
-                        printStringAt (pos b) "."
-                        return pts'
-                     _ -> errorEP "ExactP: Type: TyForall is given too few srcInfoPoints"
-        maybeEP exactPC mctxt
-        exactPC t
-    TyFun   l t1 t2 -> do
-        case srcInfoPoints l of
-         [a] -> do
-            exactP t1
-            printStringAt (pos a) "->"
-            exactPC t2
-         _ -> errorEP "ExactP: Type: TyFun is given wrong number of srcInfoPoints"
-    TyTuple l bx ts -> do
-        let pts = srcInfoPoints l
-            (o,e) = case bx of
-                     Boxed   -> ("(" , ")")
-                     Unboxed -> ("(#","#)")
-        printInterleaved (zip pts (o: replicate (length pts - 2) "," ++ [e])) ts
-    TyList  l t     -> do
-        case srcInfoPoints l of
-         [a,b] -> do
-            printString "["
-            exactPC t
-            printStringAt (pos b) "]"
-         _ -> errorEP "ExactP: Type: TyList is given wrong number of srcInfoPoints"
-    TyApp   l t1 t2 -> exactP t1 >> exactPC t2
-    TyVar   l n     -> exactP n
-    TyCon   l qn    -> exactP qn
-    TyParen l t     -> do
-        case srcInfoPoints l of
-         [a,b] -> do
-            printString "("
-            exactPC t
-            printStringAt (pos b) ")"
-         _ -> errorEP "ExactP: Type: TyParen is given wrong number of srcInfoPoints"
-    TyInfix l t1 qn t2 -> exactP t1 >> epInfixQName qn >> exactPC t2
-    TyKind  l t kd -> do
-        case srcInfoPoints l of
-         [a,b,c] -> do
-            printString "("
-            exactPC t
-            printStringAt (pos b) "::"
-            exactPC kd
-            printStringAt (pos c) ")"
-         _ -> errorEP "ExactP: Type: TyKind is given wrong number of srcInfoPoints"
-
-instance ExactP Context where
-  exactP ctxt = do
-    printContext ctxt
-    printStringAt (pos . last . srcInfoPoints . ann $ ctxt) "=>"
-
-printContext ctxt = do
-    let l = ann ctxt
-        pts = init $ srcInfoPoints l
-    case ctxt of
-     CxParen l ctxt ->
-        case pts of
-         [a,b] -> do
-            printStringAt (pos a) "("
-            printContext ctxt
-            printStringAt (pos b) ")"
-         _ -> errorEP "ExactP: Context: CxParen is given wrong number of srcInfoPoints"
-     CxSingle l asst -> exactP asst
-     CxEmpty l ->
-        case pts of
-         [a,b] -> do
-            printStringAt (pos a) "("
-            printStringAt (pos b) ")"
-         _ -> errorEP "ExactP: Context: CxEmpty is given wrong number of srcInfoPoints"
-     CxTuple l assts -> parenList pts assts
-
-
-instance ExactP Asst where
-  exactP asst = case asst of
-    ClassA l qn ts -> exactP qn >> mapM_ exactPC ts
-    InfixA l ta qn tb -> exactP ta >> epInfixQName qn >> exactPC tb
-    IParam l ipn t    ->
-        case srcInfoPoints l of
-         [a] -> do
-            exactP ipn
-            printStringAt (pos a) "::"
-            exactPC t
-         _ -> errorEP "ExactP: Asst: IParam is given wrong number of srcInfoPoints"
-    EqualP l t1 t2  ->
-        case srcInfoPoints l of
-         [a] -> do
-            exactP t1
-            printStringAt (pos a) "~"
-            exactPC t2
-
-instance ExactP Deriving where
-  exactP (Deriving l ihs) =
-    case srcInfoPoints l of
-     x:pts -> do
-        printString "deriving"
-        case pts of
-         [] -> exactPC $ head ihs
-         _  -> parenList pts ihs
-     _ -> errorEP "ExactP: Deriving is given too few srcInfoPoints"
-
-instance ExactP ClassDecl where
-  exactP cdecl = case cdecl of
-    ClsDecl    l d -> exactP d
-    ClsDataFam l mctxt dh mk ->
-        case srcInfoPoints l of
-         x:pts -> do
-            printString "data"
-            maybeEP exactPC mctxt
-            exactPC dh
-            maybeEP (\kd -> printStringAt (pos (head pts)) "::" >> exactPC kd) mk
-         _ -> errorEP "ExactP: ClassDecl: ClsDataFam is given too few srcInfoPoints"
-    ClsTyFam   l dh mk  ->
-        case srcInfoPoints l of
-         x:pts -> do
-            printString "type"
-            exactPC dh
-            maybeEP (\kd -> printStringAt (pos (head pts)) "::" >> exactPC kd) mk
-         _ -> errorEP "ExactP: ClassDecl: ClsTyFam is given too few srcInfoPoints"
-    ClsTyDef   l t1 t2  ->
-        case srcInfoPoints l of
-         a:b:pts -> do
-            printString "type"
-            exactPC t1
-            printStringAt (pos b) "="
-            exactPC t2
-         _ -> errorEP "ExactP: ClassDecl: ClsTyDef is given too few srcInfoPoints"
-
-instance ExactP InstDecl where
-  exactP idecl = case idecl of
-    InsDecl   l d -> exactP d
-    InsType   l t1 t2 ->
-        case srcInfoPoints l of
-         [a,b] -> do
-            printString "type"
-            exactPC t1
-            printStringAt (pos b) "="
-            exactPC t2
-    InsData   l dn t constrs mder -> do
-        exactP dn
-        exactPC t
-        printInterleaved (zip (srcInfoPoints l) ("=": repeat "|")) constrs
-        maybeEP exactPC mder
-    InsGData  l dn t mk gds mder  -> do
-        let pts = srcInfoPoints l
-        exactP dn
-        exactPC t
-        pts <- case mk of
-                Nothing -> return pts
-                Just kd -> case pts of
-                            p:pts' -> do
-                                printStringAt (pos p) "::"
-                                exactPC kd
-                                return pts'
-                            _ -> errorEP "ExactP: InstDecl: InsGData is given too few srcInfoPoints"
-        case pts of
-         x:_ -> do
-            printStringAt (pos x) "where"
-            mapM_ exactPC gds
-            maybeEP exactPC mder
-         _ -> errorEP "ExactP: InstDecl: InsGData is given too few srcInfoPoints"
---  InsInline l inl mact qn   -> do
---        case srcInfoPoints l of
---         [a,b] -> do
---            printString $ if inl then "{-# INLINE" else "{-# NOINLINE"
---            maybeEP exactPC mact
---            exactPC qn
---            printStringAt (pos b) "#-}" 
---         _ -> errorEP "ExactP: InstDecl: InsInline is given wrong number of srcInfoPoints"
-
-instance ExactP FunDep where
-  exactP (FunDep l nxs nys) =
-    case srcInfoPoints l of
-     [a] -> do
-        mapM_ exactPC nxs
-        printStringAt (pos a) "->"
-        mapM_ exactPC nys
-     _ -> errorEP "ExactP: FunDep is given wrong number of srcInfoPoints"
-
-instance ExactP QualConDecl where
-  exactP (QualConDecl l mtvs mctxt cd) = do
-        let pts = srcInfoPoints l
-        pts <- case mtvs of
-                Nothing -> return pts
-                Just tvs ->
-                    case pts of
-                     a:b:pts' -> do
-                        printString "forall"
-                        mapM_ exactPC tvs
-                        printStringAt (pos b) "."
-                        return pts'
-                     _ -> errorEP "ExactP: QualConDecl is given wrong number of srcInfoPoints"
-        maybeEP exactPC mctxt
-        exactPC cd
-
-instance ExactP ConDecl where
-  exactP cd = case cd of
-    ConDecl l n bts -> exactP n >> mapM_ exactPC bts
-    InfixConDecl l bta n btb -> exactP bta >> epInfixName n >> exactP btb
-    RecDecl l n fds -> exactP n >> curlyList (srcInfoPoints l) fds
-
-instance ExactP GadtDecl where
-  exactP (GadtDecl l n t) =
-    case srcInfoPoints l of
-     [a] -> do
-        exactP n
-        printStringAt (pos a) "::"
-        exactPC t
-     _ -> errorEP "ExactP: GadtDecl is given wrong number of srcInfoPoints"
-
-instance ExactP BangType where
-  exactP bt = case bt of
-    UnBangedTy l t  -> exactP t
-    BangedTy   l t  -> printString "!" >> exactPC t
-    UnpackedTy l t  ->
-      case srcInfoPoints l of
-       [a,b,c] -> do
-          printString "{-# UNPACK"
-          printStringAt (pos b) "#-}"
-          printStringAt (pos c) "!"
-          exactPC t
-       _ -> errorEP "ExactP: BangType: UnpackedTy is given wrong number of srcInfoPoints"
-
-instance ExactP Splice where
-  exactP (IdSplice l str) = printString $ '$':str
-  exactP (ParenSplice l e) =
-    case srcInfoPoints l of
-     [a,b] -> do
-        printString "$("
-        exactPC e
-        printStringAt (pos b) ")"
-     _ -> errorEP "ExactP: Splice: ParenSplice is given wrong number of srcInfoPoints"
-
-instance ExactP Exp where
-  exactP exp = case exp of
-    Var l qn        -> exactP qn
-    IPVar l ipn     -> exactP ipn
-    Con l qn        -> exactP qn
-    Lit l lit       -> exactP lit
-    InfixApp l e1 op e2 -> exactP e1 >> exactPC op >> exactPC e2
-    App l e1 e2     -> exactP e1 >> exactPC e2
-    NegApp l e      -> printString "-" >> exactPC e
-    Lambda l ps e   ->
-        case srcInfoPoints l of
-         [a,b] -> do
-            printString "\\"
-            mapM_ exactPC ps
-            printStringAt (pos b) "->"
-            exactPC e
-         _ -> errorEP "ExactP: Exp: Lambda is given wrong number of srcInfoPoints"
-    Let l bs e      ->
-        case srcInfoPoints l of
-         [a,b] -> do
-            printString "let"
-            exactPC bs
-            printStringAt (pos b) "in"
-            exactPC e
-         _ -> errorEP "ExactP: Exp: Let is given wrong number of srcInfoPoints"
-    If l ec et ee   -> -- traceShow (srcInfoPoints l) $ do
-        -- First we need to sort out if there are any optional
-        -- semicolons hiding among the srcInfoPoints.
-        case srcInfoPoints l of
-         (pIf:b:c:rest) -> do
-            let (mpSemi1,pThen,rest2) =
-                           if snd (spanSize b) == 4 -- this is "then", not a semi
-                            then (Nothing, b, c:rest)
-                            else (Just b, c, rest)
-            case rest2 of
-              (c:rest3) -> do
-                let (mpSemi2,rest4) = if snd (spanSize c) == 4 -- this is "else", not a semi
-                                       then (Nothing, rest2) 
-                                       else (Just c, rest3)
-                case rest4 of
-                  [pElse] -> do
-                    -- real work starts here:
-                    printString "if"
-                    exactPC ec
-                    maybeEP printSemi  mpSemi1
-                    printStringAt (pos pThen) "then"
-                    exactPC et
-                    maybeEP printSemi mpSemi2
-                    printStringAt (pos pElse) "else"
-                    exactPC ee
-                  [] -> errorEP "ExactP: Exp: If is given too few srcInfoPoints"
-                  _  -> errorEP "ExactP: Exp: If is given too many srcInfoPoints"
-              _ -> errorEP "ExactP: Exp: If is given too few srcInfoPoints"
-
-         _ -> errorEP "ExactP: Exp: If is given too few srcInfoPoints"
-    Case l e alts   ->
-        case srcInfoPoints l of
-         a:b:pts -> do
-            printString "case"
-            exactPC e
-            printStringAt (pos b) "of"
-            layoutList pts alts
-         _ -> errorEP "ExactP: Exp: Case is given too few srcInfoPoints"
-    Do l stmts      ->
-        case srcInfoPoints l of
-         a:pts -> do
-            printString "do"
-            layoutList pts stmts
-         _ -> errorEP "ExactP: Exp: Do is given too few srcInfoPoints"
-    MDo l stmts     ->
-        case srcInfoPoints l of
-         a:pts -> do
-            printString "mdo"
-            layoutList pts stmts
-         _ -> errorEP "ExactP: Exp: Mdo is given wrong number of srcInfoPoints"
-    Tuple l es      -> parenList (srcInfoPoints l) es
-    TupleSection l mexps    -> do
-        let pts = srcInfoPoints l
-        printSeq $ interleave (zip (map pos $ init pts) (map printString ("(": repeat ",")) ++ [(pos $ last pts, printString ")")])
-                              (map (maybe (0,0) (pos . ann) &&& maybeEP exactPC) mexps)
-    List l es               -> squareList (srcInfoPoints l) es
-    Paren l p               -> parenList (srcInfoPoints l) [p]
-    LeftSection l e qop     ->
-        case srcInfoPoints l of
-         [a,b] -> do
-            printString "("
-            exactPC e
-            exactPC qop
-            printStringAt (pos b) ")"
-         _ -> errorEP "ExactP: Exp: LeftSection is given wrong number of srcInfoPoints"
-    RightSection l qop e    ->
-        case srcInfoPoints l of
-         [a,b] -> do
-            printString "("
-            exactPC qop
-            exactPC e
-            printStringAt (pos b) ")"
-         _ -> errorEP "ExactP: Exp: RightSection is given wrong number of srcInfoPoints"
-    RecConstr l qn fups     -> do
-        let pts = srcInfoPoints l
-        exactP qn
-        curlyList pts fups
-    RecUpdate l e fups      -> do
-        let pts = srcInfoPoints l
-        exactP e
-        curlyList pts fups
-    EnumFrom l e            ->
-        case srcInfoPoints l of
-         [a,b,c] -> do
-            printString "["
-            exactPC e
-            printStringAt (pos b) ".."
-            printStringAt (pos c) "]"
-         _ -> errorEP "ExactP: Exp: EnumFrom is given wrong number of srcInfoPoints"
-    EnumFromTo l e1 e2      ->
-        case srcInfoPoints l of
-         [a,b,c] -> do
-            printString "["
-            exactPC e1
-            printStringAt (pos b) ".."
-            exactPC e2
-            printStringAt (pos c) "]"
-         _ -> errorEP "ExactP: Exp: EnumFromTo is given wrong number of srcInfoPoints"
-    EnumFromThen l e1 e2    ->
-        case srcInfoPoints l of
-         [a,b,c,d] -> do
-            printString "["
-            exactPC e1
-            printStringAt (pos b) ","
-            exactPC e2
-            printStringAt (pos c) ".."
-            printStringAt (pos d) "]"
-         _ -> errorEP "ExactP: Exp: EnumFromThen is given wrong number of srcInfoPoints"
-    EnumFromThenTo l e1 e2 e3   ->
-        case srcInfoPoints l of
-         [a,b,c,d] -> do
-            printString "["
-            exactPC e1
-            printStringAt (pos b) ","
-            exactPC e2
-            printStringAt (pos c) ".."
-            exactPC e3
-            printStringAt (pos d) "]"
-         _ -> errorEP "ExactP: Exp: EnumFromToThen is given wrong number of srcInfoPoints"
-    ListComp l e qss            ->
-        case srcInfoPoints l of
-         a:pts -> do
-            printString "["
-            exactPC e
-            bracketList ("|",",","]") pts qss
-         _ -> errorEP "ExactP: Exp: ListComp is given too few srcInfoPoints"
-    ParComp  l e qsss           ->
-        case srcInfoPoints l of
-         a:pts -> do
-            let (strs, qss) = unzip $ pairUp qsss
-            printString "["
-            exactPC e
-            printInterleaved (zip pts (strs ++ ["]"])) qss
-         _ -> errorEP "ExactP: Exp: ParComp is given wrong number of srcInfoPoints"
-      where pairUp [] = []
-            pairUp ((a:as):xs) = ("|", a) : zip (repeat ",") as ++ pairUp xs
-
-    ExpTypeSig l e t    ->
-        case srcInfoPoints l of
-         [a] -> do
-            exactP e
-            printStringAt (pos a) "::"
-            exactPC t
-         _ -> errorEP "ExactP: Exp: ExpTypeSig is given wrong number of srcInfoPoints"
-    VarQuote l qn   -> do
-      printString "'"
-      exactPC qn
-    TypQuote l qn -> do
-      printString "''"
-      exactPC qn
-    BracketExp l br -> exactP br
-    SpliceExp l sp  -> exactP sp
-    QuasiQuote l name qt    -> do
-        let qtLines = lines qt
-        printString $ "[" ++ name ++ "|"
-        sequence_ (intersperse newLine $ map printString qtLines)
-        printString "|]"
-    XTag l xn attrs mat es  -> do
-        case srcInfoPoints l of
-         [a,b,c,d,e] -> do
-            printString "<"
-            exactPC xn
-            mapM_ exactPC attrs
-            maybeEP exactPC mat
-            printStringAt (pos b) ">"
-            mapM_ exactPC es
-            printStringAt (pos c) "</"
-            printWhitespace (pos d)
-            exactP xn
-            printStringAt (pos e) ">"
-         -- TODO: Fugly hack/duplication, should be refactored
-         -- For the case when there's an optional semicolon
-         [a,b,semi,c,d,e] -> do
-            printString "<"
-            exactPC xn
-            mapM_ exactPC attrs
-            maybeEP exactPC mat
-            printStringAt (pos b) ">"
-            mapM_ exactPC es
-            printSemi semi
-            printStringAt (pos c) "</"
-            printWhitespace (pos d)
-            exactP xn
-            printStringAt (pos e) ">"
-         _ -> errorEP "ExactP: Exp: XTag is given wrong number of srcInfoPoints"
-    XETag l xn attrs mat    ->
-        case srcInfoPoints l of
-         [a,b] -> do
-            printString "<"
-            exactPC xn
-            mapM_ exactPC attrs
-            maybeEP exactPC mat
-            printStringAt (pos b) "/>"
-         _ -> errorEP "ExactP: Exp: XETag is given wrong number of srcInfoPoints"
-    XPcdata l str   -> do
-        let strLines = lines str
-        sequence_ (intersperse newLine $ map printString strLines)
-    XExpTag l e     ->
-        case srcInfoPoints l of
-         [a,b] -> do
-            printString "<%"
-            exactPC e
-            printStringAt (pos b) "%>"
-         _ -> errorEP "ExactP: Exp: XExpTag is given wrong number of srcInfoPoints"
-    XChildTag l es  ->
-        case srcInfoPoints l of
-         [a,b,c] -> do
-            printString "<%>"
-            mapM_ exactPC es
-            printStringAt (pos b) "</"
-            printStringAt (pos c) "%>"
-         -- Ugly duplication for when there's an optional semi
-         [a,semi,b,c] -> do
-            printString "<%>"
-            mapM_ exactPC es
-            printSemi semi
-            printStringAt (pos b) "</"
-            printStringAt (pos c) "%>"
-         _ -> errorEP "ExactP: Exp: XChildTag is given wrong number of srcInfoPoints"
-    CorePragma l      str e         ->
-        case srcInfoPoints l of
-         [a,b] -> do
-            printString $ "{-# CORE " ++ show str
-            printStringAt (pos b) "#-}"
-            exactPC e
-         _ -> errorEP "ExactP: Exp: CorePragma is given wrong number of srcInfoPoints"
-    SCCPragma  l      str e         ->
-        case srcInfoPoints l of
-         [a,b] -> do
-            printString $ "{-# SCC " ++ show str
-            printStringAt (pos b) "#-}"
-            exactPC e
-         _ -> errorEP "ExactP: Exp: SCCPragma is given wrong number of srcInfoPoints"
-    GenPragma  l      str (i1,i2) (i3,i4) e -> do
-        printStrs $ zip (srcInfoPoints l) ["{-# GENERATED", show str, show i1, ":", show i2, "-", show i3, ":", show i4, "#-}"]
-        exactPC e
-    Proc            l p e   ->
-        case srcInfoPoints l of
-         [a,b] -> do
-            printString "proc"
-            exactPC p
-            printStringAt (pos b) "->"
-            exactPC e
-         _ -> errorEP "ExactP: Exp: Proc is given wrong number of srcInfoPoints"
-    LeftArrApp      l e1 e2 ->
-        case srcInfoPoints l of
-         [a] -> do
-            exactP e1
-            printStringAt (pos a) "-<"
-            exactPC e2
-         _ -> errorEP "ExactP: Exp: LeftArrApp is given wrong number of srcInfoPoints"
-    RightArrApp     l e1 e2 -> do
-        case srcInfoPoints l of
-         [a] -> do
-            exactP e1
-            printStringAt (pos a) ">-"
-            exactPC e2
-         _ -> errorEP "ExactP: Exp: RightArrApp is given wrong number of srcInfoPoints"
-    LeftArrHighApp  l e1 e2 -> do
-        case srcInfoPoints l of
-         [a] -> do
-            exactP e1
-            printStringAt (pos a) "-<<"
-            exactPC e2
-         _ -> errorEP "ExactP: Exp: LeftArrHighApp is given wrong number of srcInfoPoints"
-    RightArrHighApp l e1 e2 -> do
-        case srcInfoPoints l of
-         [a] -> do
-            exactP e1
-            printStringAt (pos a) ">>-"
-            exactPC e2
-         _ -> errorEP "ExactP: Exp: RightArrHighApp is given wrong number of srcInfoPoints"
-
-instance ExactP FieldUpdate where
-  exactP fup = case fup of
-    FieldUpdate l qn e  -> do
-      case srcInfoPoints l of
-       [a] -> do
-          exactP qn
-          printStringAt (pos a) "="
-          exactPC e
-       _ -> errorEP "ExactP: FieldUpdate is given wrong number of srcInfoPoints"
-    FieldPun l n    -> exactP n
-    FieldWildcard l -> printString ".."
-
-instance ExactP Stmt where
-  exactP stmt = case stmt of
-    Generator l p e ->
-      case srcInfoPoints l of
-       [a] -> do
-          exactP p
-          printStringAt (pos a) "<-"
-          exactPC e
-       _ -> errorEP "ExactP: Stmt: Generator is given wrong number of srcInfoPoints"
-    Qualifier l e -> exactP e
-    LetStmt l bds   -> do
-      printString "let"
-      exactPC bds
-    RecStmt l ss    ->
-      case srcInfoPoints l of
-       a:pts -> do
-          printString "rec"
-          layoutList pts ss
-       _ -> errorEP "ExactP: Stmt: RecStmt is given too few srcInfoPoints"
-
-instance ExactP QualStmt where
-  exactP qstmt = case qstmt of
-    QualStmt     l stmt -> exactP stmt
-    ThenTrans    l e    -> printString "then" >> exactPC e
-    ThenBy       l e1 e2    -> do
-        case srcInfoPoints l of
-         [a,b] -> do
-            printString "then"
-            exactPC e1
-            printStringAt (pos b) "by"
-            exactPC e2
-         _ -> errorEP "ExactP: QualStmt: ThenBy is given wrong number of srcInfoPoints"
-    GroupBy      l e        -> do
-        printStrs $ zip (srcInfoPoints l) ["then","group","by"]
-        exactPC e
-    GroupUsing   l e        -> do
-        printStrs $ zip (srcInfoPoints l) ["then","group","using"]
-        exactPC e
-    GroupByUsing l e1 e2    -> do
-        let pts = srcInfoPoints l
-        printStrs $ zip (init pts) ["then","group","by"]
-        exactPC e1
-        printStringAt (pos (last pts)) "using"
-        exactPC e2
-
-instance ExactP Bracket where
-  exactP br = case br of
-    ExpBracket l e  ->
-        case srcInfoPoints l of
-         [a,b] -> do
-            printString "[|"
-            exactPC e
-            printStringAt (pos b) "|]"
-         _ -> errorEP "ExactP: Bracket: ExpBracket is given wrong number of srcInfoPoints"
-    PatBracket l p  ->
-        case srcInfoPoints l of
-         [a,b] -> do
-            printString "[p|"
-            exactPC p
-            printStringAt (pos b) "|]"
-         _ -> errorEP "ExactP: Bracket: PatBracket is given wrong number of srcInfoPoints"
-    TypeBracket l t  -> do
-        case srcInfoPoints l of
-         [a,b] -> do
-            printString "[t|"
-            exactPC t
-            printStringAt (pos b) "|]"
-         _ -> errorEP "ExactP: Bracket: TypeBracket is given wrong number of srcInfoPoints"
-    DeclBracket l ds ->
-        case srcInfoPoints l of
-         a:pts -> do
-            printString "[d|"
-            layoutList (init pts) (sepFunBinds ds)
-            printStringAt (pos (last pts)) "|]"
-         _ -> errorEP "ExactP: Bracket: DeclBracket is given too few srcInfoPoints"
-
-instance ExactP XAttr where
-  exactP (XAttr l xn e) =
-    case srcInfoPoints l of
-     [a] -> do
-        exactP xn
-        printStringAt (pos a) "="
-        exactPC e
-     _ -> errorEP "ExactP: XAttr is given wrong number of srcInfoPoints"
-
-instance ExactP Alt where
-  exactP (Alt l p galts mbs) = do
-    exactP p
-    exactPC galts
-    maybeEP (\bs -> printStringAt (pos (head (srcInfoPoints l))) "where" >> exactPC bs) mbs
-
-instance ExactP GuardedAlts where
-  exactP (UnGuardedAlt l e) = printString "->" >> exactPC e
-  exactP (GuardedAlts  l galts) = mapM_ exactPC galts
-
-instance ExactP GuardedAlt where
-  exactP (GuardedAlt l stmts e) = do
-    bracketList ("|",",","->") (srcInfoPoints l) stmts
-    exactPC e
-
-instance ExactP Match where
-  exactP (Match l n ps rhs mbinds) = do
-    let pts = srcInfoPoints l
-        len = length pts
-        pars = len `div` 2
-        (oPars,cParsWh) = splitAt pars pts
-        (cPars,whPt) = splitAt pars cParsWh    -- whPt is either singleton or empty
-    printStrs (zip oPars (repeat "("))
-    exactPC n
-    printStreams (zip (map pos cPars) (repeat $ printString ")")) (map (pos . ann &&& exactPC) ps) 
-    exactPC rhs
-    maybeEP (\bds -> printStringAt (pos (head pts)) "where" >> exactPC bds) mbinds
-  exactP (InfixMatch l a n bs rhs mbinds) = do
-    let pts = srcInfoPoints l
-        len = length pts
-        pars = len `div` 2
-        (oPars,cParsWh) = splitAt pars pts
-        (cPars,whPt) = splitAt pars cParsWh    -- whPt is either singleton or empty
-    printStrs (zip oPars (repeat "("))
-    exactPC a
-    epInfixName n
-    printInterleaved' (zip cPars (repeat ")")) bs
-    exactPC rhs
-    maybeEP (\bds -> printStringAt (pos (head whPt)) "where" >> exactPC bds) mbinds
-
-instance ExactP Rhs where
-  exactP (UnGuardedRhs l e) = printString "=" >> exactPC e
-  exactP (GuardedRhss  l grhss) = mapM_ exactPC grhss
-
-instance ExactP GuardedRhs where
-  exactP (GuardedRhs l ss e) =
-    case srcInfoPoints l of
-     a:pts -> do
-        printString "|"
-        printInterleaved' (zip (init pts) (repeat ",") ++ [(last pts, "=")]) ss
-        exactPC e
-     _ -> errorEP "ExactP: GuardedRhs is given wrong number of srcInfoPoints"
-
-instance ExactP Pat where
-  exactP pat = case pat of
-    PVar l n    -> exactP n
-    PLit l lit  -> exactP lit
-    PNeg l p    -> printString "-" >> exactPC p
-    PNPlusK l n k   ->
-        case srcInfoPoints l of
-         [a,b] -> do
-            exactP n
-            printStringAt (pos a) "+"
-            printStringAt (pos b) (show k)
-         _ -> errorEP "ExactP: Pat: PNPlusK is given wrong number of srcInfoPoints"
-    PInfixApp l pa qn pb -> exactP pa >> epInfixQName qn >> exactPC pb
-    PApp l qn ps    -> exactP qn >> mapM_ exactPC ps
-    PTuple l ps -> parenList (srcInfoPoints l) ps
-    PList l ps  -> squareList (srcInfoPoints l) ps
-    PParen l p  -> parenList (srcInfoPoints l) [p]
-    PRec l qn pfs   -> exactP qn >> curlyList (srcInfoPoints l) pfs
-    PAsPat l n p    ->
-        case srcInfoPoints l of
-         [a] -> do
-            exactP n
-            printStringAt (pos a) "@"
-            exactPC p
-         _ -> errorEP "ExactP: Pat: PAsPat is given wrong number of srcInfoPoints"
-    PWildCard l -> printString "_"
-    PIrrPat l p -> printString "~" >> exactPC p
-    PatTypeSig l p t ->
-        case srcInfoPoints l of
-         [a] -> do
-            exactP p
-            printStringAt (pos a) "::"
-            exactPC t
-         _ -> errorEP "ExactP: Pat: PatTypeSig is given wrong number of srcInfoPoints"
-    PViewPat l e p ->
-        case srcInfoPoints l of
-         [a] -> do
-            exactP e
-            printStringAt (pos a) "->"
-            exactPC p
-         _ -> errorEP "ExactP: Pat: PViewPat is given wrong number of srcInfoPoints"
-    PRPat l rps -> squareList (srcInfoPoints l) rps
-    PXTag l xn attrs mat ps ->
-        case srcInfoPoints l of
-         [a,b,c,d,e] -> do
-            printString "<"
-            exactPC xn
-            mapM_ exactPC attrs
-            maybeEP exactPC mat
-            printStringAt (pos b) ">"
-            mapM_ exactPC ps
-            printStringAt (pos c) "</"
-            printWhitespace (pos d)
-            exactP xn
-            printStringAt (pos e) ">"
-         -- Optional semi
-         [a,b,semi,c,d,e] -> do
-            printString "<"
-            exactPC xn
-            mapM_ exactPC attrs
-            maybeEP exactPC mat
-            printStringAt (pos b) ">"
-            mapM_ exactPC ps
-            printSemi semi
-            printStringAt (pos c) "</"
-            printWhitespace (pos d)
-            exactP xn
-            printStringAt (pos e) ">"
-         _ -> errorEP "ExactP: Pat: PXTag is given wrong number of srcInfoPoints"
-    PXETag l xn attrs mat ->
-        case srcInfoPoints l of
-         [a,b] -> do
-            printString "<"
-            exactPC xn
-            mapM_ exactPC attrs
-            maybeEP exactPC mat
-            printStringAt (pos b) "/>"
-         _ -> errorEP "ExactP: Pat: PXETag is given wrong number of srcInfoPoints"
-    PXPcdata l str -> printString str
-    PXPatTag l p   ->
-        case srcInfoPoints l of
-         [a,b] -> do
-            printString "<%"
-            exactPC p
-            printString "%>"
-         _ -> errorEP "ExactP: Pat: PXPatTag is given wrong number of srcInfoPoints"
-    PXRPats  l rps  -> bracketList ("<[",",","]>") (srcInfoPoints l) rps
-    PExplTypeArg l qn t ->
-        case srcInfoPoints l of
-         [a,b] -> do
-            exactP qn
-            printStringAt (pos a) "{|"
-            exactPC t
-            printStringAt (pos b) "|}"
-         _ -> errorEP "ExactP: Pat: PExplTypeArg is given wrong number of srcInfoPoints"
-    PQuasiQuote l name qt   -> printString $ "[$" ++ name ++ "|" ++ qt ++ "]"
-    PBangPat l p    -> printString "!" >> exactPC p
-
-instance ExactP PatField where
-  exactP pf = case pf of
-    PFieldPat l qn p        ->
-        case srcInfoPoints l of
-         [a] -> do
-            exactP qn
-            printStringAt (pos a) "="
-            exactPC p
-         _ -> errorEP "ExactP: PatField: PFieldPat is given wrong number of srcInfoPoints"
-    PFieldPun l n   -> exactP n
-    PFieldWildcard l -> printString ".."
-
-instance ExactP RPat where
-  exactP rpat = case rpat of
-    RPOp l rp op    -> exactP rp >> exactPC op
-    RPEither l r1 r2 ->
-      case srcInfoPoints l of
-       [a] -> do
-          exactP r1
-          printStringAt (pos a) "|"
-          exactPC r2
-       _ -> errorEP "ExactP: RPat: RPEither is given wrong number of srcInfoPoints"
-    RPSeq l rps -> bracketList ("(|",",","|)") (srcInfoPoints l) rps
-    RPGuard l p stmts   ->
-      case srcInfoPoints l of
-       a:pts -> do
-          printString "(|"
-          exactPC p
-          bracketList ("|",",","|)") pts stmts
-       _ -> errorEP "ExactP: RPat: RPGuard is given wrong number of srcInfoPoints"
-    RPCAs l n rp    ->
-      case srcInfoPoints l of
-       [a] -> do
-          exactP n
-          printStringAt (pos a) "@:"
-          exactPC rp
-       _ -> errorEP "ExactP: RPat: RPCAs is given wrong number of srcInfoPoints"
-    RPAs l n rp     ->
-      case srcInfoPoints l of
-       [a] -> do
-          exactP n
-          printStringAt (pos a) "@"
-          exactPC rp
-       _ -> errorEP "ExactP: RPat: RPAs is given wrong number of srcInfoPoints"
-    RPParen l rp    -> do
-      parenList (srcInfoPoints l) [rp]
-    RPPat l p   -> exactP p
-
-instance ExactP RPatOp where
-  exactP rop = printString $ case rop of
-    RPStar  l  -> "*"
-    RPStarG l  -> "*!"
-    RPPlus  l  -> "+"
-    RPPlusG l  -> "+!"
-    RPOpt   l  -> "?"
-    RPOptG  l  -> "?!"
-
-instance ExactP PXAttr where
-  exactP (PXAttr l xn p) =
-    case srcInfoPoints l of
-     [a] -> do
-        exactP xn
-        printStringAt (pos a) "="
-        exactPC p
-     _ -> errorEP "ExactP: PXAttr is given wrong number of srcInfoPoints"
-
-instance ExactP XName where
-  exactP xn = case xn of
-    XName l name -> printString name
-    XDomName l dom name ->
-        case srcInfoPoints l of
-         [a,b,c] -> do
-            printString dom
-            printStringAt (pos b) ":"
-            printStringAt (pos c) name
-         _ -> errorEP "ExactP: XName: XDomName is given wrong number of srcInfoPoints"
-
-instance ExactP Binds where
-  exactP (BDecls  l ds)  = layoutList (srcInfoPoints l) (sepFunBinds ds)
-  exactP (IPBinds l ips) = layoutList (srcInfoPoints l) ips
-
-instance ExactP CallConv where
-  exactP (StdCall   _) = printString "stdcall"
-  exactP (CCall     _) = printString "ccall"
-  exactP (CPlusPlus _) = printString "cplusplus"
-  exactP (DotNet    _) = printString "dotnet"
-  exactP (Jvm       _) = printString "jvm"
-  exactP (Js        _) = printString "js"
-
-instance ExactP Safety where
-  exactP (PlayRisky _) = printString "unsafe"
-  exactP (PlaySafe _ b) = printString $ if b then "threadsafe" else "safe"
-
-instance ExactP Rule where
-  exactP (Rule l str mact mrvs e1 e2) =
-    case srcInfoPoints l of
-     a:pts -> do
-        printString (show str)
-        maybeEP exactP mact
-        pts <- case mrvs of
-                Nothing -> return pts
-                Just rvs ->
-                    case pts of
-                     a:b:pts' -> do
-                        printStringAt (pos a) "forall"
-                        mapM_ exactPC rvs
-                        printStringAt (pos b) "."
-                        return pts'
-                     _ -> errorEP "ExactP: Rule is given too few srcInfoPoints"
-        case pts of
-         [x] -> do
-            exactPC e1
-            printStringAt (pos x) "="
-            exactPC e2
-         _ -> errorEP "ExactP: Rule is given wrong number of srcInfoPoints"
-     _ -> errorEP "ExactP: Rule is given too few srcInfoPoints"
-
-instance ExactP RuleVar where
-  exactP (TypedRuleVar l n t) = do
-        case srcInfoPoints l of
-         [a,b,c] -> do
-            printString "("
-            exactPC n
-            printStringAt (pos b) "::"
-            exactPC t
-            printStringAt (pos c) ")"
-         _ -> errorEP "ExactP: RuleVar: TypedRuleVar is given wrong number of srcInfoPoints"
-  exactP (RuleVar l n) = exactP n
-
-instance ExactP Activation where
-  exactP (ActiveFrom   l i) =
-    printPoints l ["[", show i, "]"]
-  exactP (ActiveUntil  l i) =
-    printPoints l ["[", "~", show i, "]"]
-
-instance ExactP FieldDecl where
-  exactP (FieldDecl l ns bt) = do
-    let pts = srcInfoPoints l
-    printInterleaved' (zip (init pts) (repeat ",") ++ [(last pts, "::")]) ns
-    exactPC bt
-
-instance ExactP IPBind where
-  exactP (IPBind l ipn e) = do
-    case srcInfoPoints l of
-     [a] -> do
-        exactP ipn
-        printStringAt (pos a) "="
-        exactPC e
-     _ -> errorEP "ExactP: IPBind is given wrong number of srcInfoPoints"
+-----------------------------------------------------------------------------+-- |+-- Module      :  Language.Haskell.Exts.Annotated.ExactPrint+-- Copyright   :  (c) Niklas Broberg 2009+-- License     :  BSD-style (see the file LICENSE.txt)+--+-- Maintainer  :  Niklas Broberg, d00nibro@chalmers.se+-- Stability   :  stable+-- Portability :  portable+--+-- Exact-printer for Haskell abstract syntax. The input is a (semi-concrete)+-- abstract syntax tree, annotated with exact source information to enable+-- printing the tree exactly as it was parsed.+--+-----------------------------------------------------------------------------+module Language.Haskell.Exts.Annotated.ExactPrint+        ( exactPrint+        , ExactP+        ) where++import Language.Haskell.Exts.Annotated.Syntax+import Language.Haskell.Exts.SrcLoc+import Language.Haskell.Exts.Comments++import Control.Monad (when)+import Control.Arrow ((***), (&&&))+import Data.List (intersperse)++-- import Debug.Trace (trace)++------------------------------------------------------+-- The EP monad and basic combinators++type Pos = (Int,Int)++pos :: (SrcInfo loc) => loc -> Pos+pos ss = (startLine ss, startColumn ss)++newtype EP x = EP (Pos -> [Comment] -> (x, Pos, [Comment], ShowS))++instance Monad EP where+  return x = EP $ \l cs -> (x, l, cs, id)++  EP m >>= k = EP $ \l0 c0 -> let+        (a, l1, c1, s1) = m l0 c0+        EP f = k a+        (b, l2, c2, s2) = f l1 c1+    in (b, l2, c2, s1 . s2)++runEP :: EP () -> [Comment] -> String+runEP (EP f) cs = let (_,_,_,s) = f (1,1) cs in s ""++getPos :: EP Pos+getPos = EP (\l cs -> (l,l,cs,id))++setPos :: Pos -> EP ()+setPos l = EP (\_ cs -> ((),l,cs,id))++printString :: String -> EP ()+printString str = EP (\(l,c) cs -> ((), (l,c+length str), cs, showString str))++getComment :: EP (Maybe Comment)+getComment = EP $ \l cs ->+    let x = case cs of+             c:_ -> Just c+             _   -> Nothing+     in (x, l, cs, id)++dropComment :: EP ()+dropComment = EP $ \l cs ->+    let cs' = case cs of+               (_:cs) -> cs+               _      -> cs+     in ((), l, cs', id)++newLine :: EP ()+newLine = do+    (l,_) <- getPos+    printString "\n"+    setPos (l+1,1)++padUntil :: Pos -> EP ()+padUntil (l,c) = do+    (l1,c1) <- getPos+    case  {- trace (show ((l,c), (l1,c1))) -} () of+     _ {-()-} | l1 >= l && c1 <= c -> printString $ replicate (c - c1) ' '+              | l1 < l             -> newLine >> padUntil (l,c)+              | otherwise          -> return ()+++mPrintComments :: Pos -> EP ()+mPrintComments p = do+    mc <- getComment+    case mc of+     Nothing -> return ()+     Just (Comment multi s str) ->+        when (pos s < p) $ do+            dropComment+            padUntil (pos s)+            printComment multi str+            setPos (srcSpanEndLine s, srcSpanEndColumn s)+            mPrintComments p++printComment :: Bool -> String -> EP ()+printComment b str+    | b         = printString $ "{-" ++ str ++ "-}"+    | otherwise = printString $ "--" ++ str++printWhitespace :: Pos -> EP ()+printWhitespace p = mPrintComments p >> padUntil p++printStringAt :: Pos -> String -> EP ()+printStringAt p str = printWhitespace p >> printString str++errorEP :: String -> EP a+errorEP = fail++------------------------------------------------------------------------------+-- Printing of source elements++-- | Print an AST exactly as specified by the annotations on the nodes in the tree.+exactPrint :: (ExactP ast) => ast SrcSpanInfo -> [Comment] -> String+exactPrint ast cs = runEP (exactPC ast) cs++exactPC :: (ExactP ast) => ast SrcSpanInfo -> EP ()+exactPC ast = let p = pos (ann ast) in mPrintComments p >> padUntil p >> exactP ast++printSeq :: [(Pos, EP ())] -> EP ()+printSeq [] = return ()+printSeq ((p,pr):xs) = printWhitespace p >> pr >> printSeq xs++printStrs :: SrcInfo loc => [(loc, String)] -> EP ()+printStrs = printSeq . map (pos *** printString)++printPoints :: SrcSpanInfo -> [String] -> EP ()+printPoints l = printStrs . zip (srcInfoPoints l)++printInterleaved, printInterleaved' :: (Annotated ast, ExactP ast, SrcInfo loc) => [(loc, String)] -> [ast SrcSpanInfo] -> EP ()+printInterleaved sistrs asts = printSeq $+    interleave (map (pos *** printString ) sistrs)+               (map (pos . ann &&& exactP) asts)++printInterleaved' sistrs (a:asts) = exactPC a >> printInterleaved sistrs asts++printStreams :: [(Pos, EP ())] -> [(Pos, EP ())] -> EP ()+printStreams [] ys = printSeq ys+printStreams xs [] = printSeq xs+printStreams (x@(p1,ep1):xs) (y@(p2,ep2):ys)+    | p1 <= p2 = printWhitespace p1 >> ep1 >> printStreams xs (y:ys)+    | otherwise = printWhitespace p2 >> ep2 >> printStreams (x:xs) ys+++interleave :: [a] -> [a] -> [a]+interleave [] ys = ys+interleave xs [] = xs+interleave (x:xs) (y:ys) = x:y: interleave xs ys++maybeEP :: (a -> EP ()) -> Maybe a -> EP ()+maybeEP = maybe (return ())++bracketList :: (Annotated ast, ExactP ast) => (String, String, String) -> [SrcSpan] -> [ast SrcSpanInfo] -> EP ()+bracketList (a,b,c) poss asts = printInterleaved (pList poss (a,b,c)) asts++pList (p:ps) (a,b,c) = (p,a) : pList' ps (b,c)+pList' [] _ = []+pList' [p] (_,c) = [(p,c)]+pList' (p:ps) (b,c) = (p, b) : pList' ps (b,c)++parenList, squareList, curlyList, parenHashList :: (Annotated ast, ExactP ast) => [SrcSpan] -> [ast SrcSpanInfo] -> EP ()+parenList = bracketList ("(",",",")")+squareList = bracketList ("[",",","]")+curlyList = bracketList ("{",",","}")+parenHashList = bracketList ("(#",",","#)")++layoutList :: (Functor ast, Show (ast ()), Annotated ast, ExactP ast) => [SrcSpan] -> [ast SrcSpanInfo] -> EP ()+layoutList poss asts = printStreams+        (map (pos *** printString) $ lList poss)+        (map (pos . ann &&& exactP) asts)++lList (p:ps) = (if isNullSpan p then (p,"") else (p,"{")) : lList' ps+lList' [] = []+lList' [p] = [if isNullSpan p then (p,"") else (p,"}")]+lList' (p:ps) = (if isNullSpan p then (p,"") else (p,";")) : lList' ps++printSemi :: SrcSpan -> EP ()+printSemi p = do+  printWhitespace (pos p)+  when (not $ isNullSpan p) $ printString ";"+++--------------------------------------------------+-- Exact printing++class Annotated ast => ExactP ast where+  exactP :: ast SrcSpanInfo -> EP ()++instance ExactP Literal where+  exactP lit = case lit of+    Char       _ _ rw -> printString ('\'':rw ++ "\'")+    String     _ _ rw -> printString ('\"':rw ++ "\"")+    Int        _ _ rw -> printString (rw)+    Frac       _ _ rw -> printString (rw)+    PrimInt    _ _ rw -> printString (rw ++ "#" )+    PrimWord   _ _ rw -> printString (rw ++ "##")+    PrimFloat  _ _ rw -> printString (rw ++ "#" )+    PrimDouble _ _ rw -> printString (rw ++ "##")+    PrimChar   _ _ rw -> printString ('\'':rw ++ "\'#" )+    PrimString _ _ rw -> printString ('\"':rw ++ "\"#" )++instance ExactP ModuleName where+  exactP (ModuleName l str) = printString str++instance ExactP SpecialCon where+  exactP sc = case sc of+    UnitCon l   -> printPoints l ["(",")"]+    ListCon l   -> printPoints l ["[","]"]+    FunCon  l   -> printPoints l ["(","->",")"]+    TupleCon l b n -> printPoints l $+        case b of+         Unboxed -> "(#": replicate (n-1) "," ++ ["#)"]+         _       -> "(" : replicate (n-1) "," ++ [")"]+    Cons l      -> printString ":"+    UnboxedSingleCon l -> printPoints l ["(#","#)"]++isSymbol :: Name l -> Bool+isSymbol (Symbol _ _) = True+isSymbol _ = False++getName :: QName l -> Name l+getName (UnQual _ s) = s+getName (Qual _ _ s) = s+getName (Special l (Cons _)) = Symbol l ":"+getName (Special l (FunCon _)) = Symbol l "->"+getName (Special l s) = Ident l (specialName s)++specialName :: SpecialCon l -> String+specialName (UnitCon _) = "()"+specialName (ListCon _) = "[]"+specialName (FunCon  _) = "->"+specialName (TupleCon _ b n) = "(" ++ hash ++ replicate (n-1) ',' ++ hash ++ ")"+    where hash = case b of+                   Unboxed -> "#"+                   _       -> ""+specialName (Cons _) = ":"++instance ExactP QName where+  exactP qn+    | isSymbol (getName qn) = do+        case srcInfoPoints (ann qn) of+         [a,b,c] -> do+            printString "("+            printWhitespace (pos b)+            epQName qn+            printStringAt (pos c) ")"+         _ -> errorEP "ExactP: QName is given wrong number of srcInfoPoints"+    | otherwise = epQName qn++epQName :: QName SrcSpanInfo -> EP ()+epQName qn = case qn of+    Qual    l mn n  -> exactP mn >> printString "." >> epName n+    UnQual  l    n  -> epName n+    Special l sc    -> exactP sc++epInfixQName :: QName SrcSpanInfo -> EP ()+epInfixQName qn+    | isSymbol (getName qn) = printWhitespace (pos (ann qn)) >> epQName qn+    | otherwise = do+        case srcInfoPoints (ann qn) of+         [a,b,c] -> do+            printStringAt (pos a) "`"+            printWhitespace (pos b)+            epQName qn+            printStringAt (pos c) "`"+         _ -> errorEP "ExactP: QName (epInfixName) is given wrong number of srcInfoPoints"++instance ExactP Name where+  exactP n = case n of+    Ident  l str    -> printString str+    Symbol l str    -> do+        case srcInfoPoints l of+         [a,b,c] -> do+            printString "("+            printWhitespace (pos b)+            printString str+            printStringAt (pos c) ")"+         _ -> errorEP "ExactP: Name is given wrong number of srcInfoPoints"++epName :: Name SrcSpanInfo -> EP ()+epName (Ident  _ str) = printString str+epName (Symbol _ str) = printString str++epInfixName :: Name SrcSpanInfo -> EP ()+epInfixName n+    | isSymbol n = printWhitespace (pos (ann n)) >> epName n+    | otherwise = do+        case srcInfoPoints (ann n) of+         [a,b,c] -> do+            printStringAt (pos a) "`"+            printWhitespace (pos b)+            epName n+            printStringAt (pos c) "`"+         _ -> errorEP "ExactP: Name (epInfixName) is given wrong number of srcInfoPoints"++instance ExactP IPName where+  exactP ipn = case ipn of+    IPDup l str -> printString $ '?':str+    IPLin l str -> printString $ '%':str++instance ExactP QOp where+  exactP qop = case qop of+    QVarOp l qn -> epInfixQName qn+    QConOp l qn -> epInfixQName qn++instance ExactP Op where+  exactP op = case op of+    VarOp l n -> epInfixName n+    ConOp l n -> epInfixName n++++instance ExactP CName where+  exactP cn = case cn of+    VarName l n -> exactP n+    ConName l n -> exactP n++instance ExactP ExportSpec where+  exactP espec = case espec of+     EVar l qn      -> exactP qn+     EAbs l qn      -> exactP qn+     EThingAll l qn -> exactP qn >> printPoints l ["(","..",")"]+     EThingWith l qn cns    ->+        let k = length (srcInfoPoints l)+         in exactP qn >> printInterleaved (zip (srcInfoPoints l) $ "(":replicate (k-2) "," ++ [")"]) cns+     EModuleContents l mn -> printString "module" >> exactPC mn++instance ExactP ExportSpecList where+  exactP (ExportSpecList l ess) =+    let k = length (srcInfoPoints l)+     in printInterleaved (zip (srcInfoPoints l) $ "(": replicate (k-2) "," ++ [")"]) ess++instance ExactP ImportSpecList where+  exactP (ImportSpecList l hid ispecs) = do+    let pts = srcInfoPoints l+    pts <- if hid then do+             let (x:pts') = pts+             printStringAt (pos x) "hiding"+             return pts'+            else return pts+    let k = length pts+    printInterleaved (zip pts $ "(": replicate (k-2) "," ++ [")"]) ispecs++instance ExactP ImportSpec where+  exactP ispec = case ispec of+    IVar l n    -> exactP n+    IAbs l n    -> exactP n+    IThingAll l n   -> exactP n >> printPoints l ["(","..",")"]+    IThingWith l n cns    ->+        let k = length (srcInfoPoints l)+         in exactP n >> printInterleaved (zip (srcInfoPoints l) $ "(":replicate (k-2) "," ++ [")"]) cns++instance ExactP ImportDecl where+  exactP (ImportDecl l mn qf src mpkg mas mispecs) = do+    printString "import"+    case srcInfoPoints l of+     (a:pts) -> do+        pts <- if src then+                 case pts of+                  x:y:pts' -> do+                     printStringAt (pos x) "{-# SOURCE"+                     printStringAt (pos y) "#-}"+                     return pts'+                  _ -> errorEP "ExactP: ImportDecl is given too few srcInfoPoints"+                else return pts+        pts <- if qf then+                 case pts of+                  x:pts' -> do+                     printStringAt (pos x) "qualified"+                     return pts'+                  _ -> errorEP "ExactP: ImportDecl is given too few srcInfoPoints"+                else return pts+        pts <- case mpkg of+                Just pkg ->+                  case pts of+                   x:pts' -> do+                      printStringAt (pos x) $ show pkg+                      return pts'+                   _ -> errorEP "ExactP: ImportDecl is given too few srcInfoPoints"+                _ -> return pts+        exactPC mn+        pts <- case mas of+                Just as ->+                 case pts of+                  x:pts' -> do+                     printStringAt (pos x) "as"+                     exactPC as+                     return pts'+                  _ -> errorEP "ExactP: ImportDecl is given too few srcInfoPoints"+                _ -> return pts+        case mispecs of+         Nothing -> return ()+         Just ispecs -> exactPC ispecs+     _ -> errorEP "ExactP: ImportDecl is given too few srcInfoPoints"++instance ExactP Module where+  exactP mdl = case mdl of+    Module l mmh oss ids decls -> do+        let (oPts, pts) = splitAt (max (length oss + 1) 2) (srcInfoPoints l)+        layoutList oPts oss+        maybeEP exactPC mmh+        printStreams (map (pos *** printString) $ lList pts)+                     (map (pos . ann &&& exactPC) ids ++ map (pos . ann &&& exactPC) (sepFunBinds decls))+    XmlPage l _mn oss xn attrs mat es  -> do+        let (oPts, pPts) = splitAt (max (length oss + 1) 2) $ srcInfoPoints l+        case pPts of+         [a,b,c,d,e] -> do+            layoutList oPts oss+            printStringAt (pos a) "<"+            exactPC xn+            mapM_ exactPC attrs+            maybeEP exactPC mat+            printStringAt (pos b) ">"+            mapM_ exactPC es+            printStringAt (pos c) "</"+            printWhitespace (pos d)+            exactP xn+            printStringAt (pos e) ">"+         _ -> errorEP "ExactP: Module: XmlPage is given wrong number of srcInfoPoints"+    XmlHybrid l mmh oss ids decls xn attrs mat es -> do+        let (oPts, pts) = splitAt (max (length oss + 1) 2) (srcInfoPoints l)+        layoutList oPts oss+        maybeEP exactPC mmh+        let (dPts, pPts) = splitAt (length pts - 5) pts+        case pPts of+         [a,b,c,d,e] -> do+            printStreams (map (\(p,s) -> (pos p, printString s)) $ lList dPts)+                         (map (\i -> (pos $ ann i, exactPC i)) ids ++ map (\d -> (pos $ ann d, exactPC d)) (sepFunBinds decls))++            printStringAt (pos a) "<"+            exactPC xn+            mapM_ exactPC attrs+            maybeEP exactPC mat+            printStringAt (pos b) ">"+            mapM_ exactPC es+            printStringAt (pos c) "</"+            printWhitespace (pos d)+            exactP xn+            printStringAt (pos e) ">"+         _ -> errorEP "ExactP: Module: XmlHybrid is given wrong number of srcInfoPoints"++instance ExactP ModuleHead where+  exactP (ModuleHead l mn mwt mess) = do+    case srcInfoPoints l of+     [a,b] -> do+        printStringAt (pos a) "module"+        exactPC mn+        maybeEP exactPC mwt+        maybeEP exactPC mess+        printStringAt (pos b) "where"+     _ -> errorEP "ExactP: ModuleHead is given wrong number of srcInfoPoints"++instance ExactP ModulePragma where+  exactP op = case op of+    LanguagePragma   l ns       ->+        let pts = srcInfoPoints l+            k = length ns - 1 -- number of commas+            m = length pts - k - 2 -- number of virtual semis, likely 0+         in printInterleaved (zip pts ("{-# LANGUAGE":replicate k "," ++ replicate m "" ++ ["#-}"])) ns+    OptionsPragma    l mt str   ->+        let k = length (srcInfoPoints l)+            opstr = "{-# OPTIONS" ++ case mt of { Just t -> "_" ++ show t ; _ -> "" } ++ " " ++ str+         in printPoints l $ opstr : replicate (k-2) "" ++ ["#-}"]+    AnnModulePragma  l ann       ->+        case srcInfoPoints l of+         [a,b] -> do+            printString $ "{-# ANN"+            exactPC ann+            printStringAt (pos b) "#-}"+         _ -> errorEP "ExactP: ModulePragma: AnnPragma is given wrong number of srcInfoPoints"++instance ExactP WarningText where+    exactP (DeprText l str) = printPoints l ["{-# DEPRECATED", str, "#-}"]+    exactP (WarnText l str) = printPoints l ["{-# WARNING",    str, "#-}"]++instance ExactP Assoc where+  exactP a = case a of+    AssocNone  l -> printString "infix"+    AssocLeft  l -> printString "infixl"+    AssocRight l -> printString "infixr"++instance ExactP DataOrNew where+  exactP (DataType l) = printString "data"+  exactP (NewType  l) = printString "newtype"++instance ExactP Decl where+  exactP decl = case decl of+    TypeDecl     l dh t      ->+        case srcInfoPoints l of+         [a,b] -> do+            printStringAt (pos a) "type"+            exactPC dh+            printStringAt (pos b) "="+            exactPC t+         _ -> errorEP "ExactP: Decl: TypeDecl is given wrong number of srcInfoPoints"+    TypeFamDecl  l dh mk     ->+        case srcInfoPoints l of+         a:b:ps -> do+            printStringAt (pos a) "type"+            printStringAt (pos b) "family"+            exactPC dh+            maybeEP (\k -> printStringAt (pos (head ps)) "::" >> exactPC k) mk+         _ -> errorEP "ExactP: Decl: TypeFamDecl is given wrong number of srcInfoPoints"+    DataDecl     l dn mctxt dh constrs mder -> do+        exactP dn+        maybeEP exactPC mctxt+        exactPC dh+        -- the next line works for empty data types since the srcInfoPoints will be empty then+        printInterleaved (zip (srcInfoPoints l) ("=": repeat "|")) constrs+        maybeEP exactPC mder+    GDataDecl    l dn mctxt dh mk gds mder -> do+        let pts = srcInfoPoints l+        exactP dn+        maybeEP exactPC mctxt+        exactPC dh+        pts <- case mk of+                Nothing -> return pts+                Just kd -> case pts of+                            p:pts' -> do+                               printStringAt (pos p) "::"+                               exactPC kd+                               return pts'+                            _ -> errorEP "ExactP: Decl: GDataDecl is given too few srcInfoPoints"+        case pts of+         x:pts -> do+            printStringAt (pos x) "where"+            layoutList pts gds+            maybeEP exactPC mder+         _ -> errorEP "ExactP: Decl: GDataDecl is given too few srcInfoPoints"+    DataFamDecl  l mctxt dh mk -> do+        printString "data"+        maybeEP exactPC mctxt+        exactPC dh+        maybeEP (\kd -> printStringAt (pos (head (srcInfoPoints l))) "::" >> exactPC kd) mk+    TypeInsDecl  l t1 t2 ->+        case srcInfoPoints l of+         [a,b,c] -> do+            printString "type"+            printStringAt (pos b) "instance"+            exactPC t1+            printStringAt (pos c) "="+            exactPC t2+         _ -> errorEP "ExactP: Decl: TypeInsDecl is given wrong number of srcInfoPoints"+    DataInsDecl  l dn t constrs mder    ->+        case srcInfoPoints l of+         p:pts -> do+            exactP dn+            printStringAt (pos p) "instance"+            exactPC t+            printInterleaved (zip pts ("=": repeat "|")) constrs+            maybeEP exactPC mder+         _ -> errorEP "ExactP: Decl: DataInsDecl is given too few srcInfoPoints"+    GDataInsDecl l dn t mk gds mder     ->+        case srcInfoPoints l of+         p:pts -> do+            exactP dn+            printStringAt (pos p) "instance"+            exactPC t+            pts <- case mk of+                    Nothing -> return pts+                    Just kd -> case pts of+                                p:pts' -> do+                                    printStringAt (pos p) "::"+                                    exactPC kd+                                    return pts'+                                _ -> errorEP "ExactP: Decl: GDataInsDecl is given too few srcInfoPoints"+            case pts of+             x:pts -> do+                printStringAt (pos x) "where"+                layoutList pts gds+                maybeEP exactPC mder+             _ -> errorEP "ExactP: Decl: GDataInsDecl is given too few srcInfoPoints"+         _ -> errorEP "ExactP: Decl: GDataInsDecl is given too few srcInfoPoints"+    ClassDecl    l mctxt dh fds mcds    ->+        case srcInfoPoints l of+         a:pts -> do+            printString "class"+            maybeEP exactPC mctxt+            exactPC dh+            pts <- case fds of+                    [] -> return pts+                    _  -> do+                      let (pts1, pts2) = splitAt (length fds) pts+                      printInterleaved (zip pts1 ("|":repeat ",")) fds+                      return pts2+            maybeEP (\cds ->+                case pts of+                 p:pts' -> do+                    printStringAt (pos p) "where"+                    layoutList pts' $ sepClassFunBinds cds+                 _ -> errorEP "ExactP: Decl: ClassDecl is given too few srcInfoPoints"+                ) mcds+         _ -> errorEP "ExactP: Decl: ClassDecl is given too few srcInfoPoints"+    InstDecl     l mctxt ih mids        ->+        case srcInfoPoints l of+         a:pts -> do+            printString "instance"+            maybeEP exactPC mctxt+            exactPC ih+            maybeEP (\ids -> do+                let (p:pts') = pts+                printStringAt (pos p) "where"+                layoutList pts' $ sepInstFunBinds ids+                ) mids+         _ -> errorEP "ExactP: Decl: InstDecl is given too few srcInfoPoints"+    DerivDecl    l mctxt ih             ->+        case srcInfoPoints l of+         [a,b] -> do+            printString "deriving"+            printStringAt (pos b) "instance"+            maybeEP exactPC mctxt+            exactPC ih+         _ -> errorEP "ExactP: Decl: DerivDecl is given wrong number of srcInfoPoints"+    InfixDecl    l assoc mprec ops      -> do+        let pts = srcInfoPoints l+        exactP assoc+        pts <- case mprec of+                Nothing -> return pts+                Just prec ->+                    case pts of+                     p:pts' -> do+                        printStringAt (pos p) (show prec)+                        return pts'+                     _ -> errorEP "ExactP: Decl: InfixDecl is given too few srcInfoPoints"+        printInterleaved' (zip pts (repeat ",")) ops+    DefaultDecl  l ts   ->+        case srcInfoPoints l of+         a:pts -> do+            printString "default"+            printInterleaved (zip (init pts) ("(":repeat ",")) ts+            printStringAt (pos (last pts)) ")"+         _ -> errorEP "ExactP: Decl: DefaultDecl is given too few srcInfoPoints"+    SpliceDecl   l spl  -> exactP spl+    TypeSig      l ns t -> do+        let pts = srcInfoPoints l+        printInterleaved' (zip pts (replicate (length pts - 1) "," ++ ["::"])) ns+        exactPC t+    FunBind      l ms   -> mapM_ exactPC ms+    PatBind      l p mt rhs mbs -> do+        let pts = srcInfoPoints l+        exactP p+        pts <- case mt of+                Nothing -> return pts+                Just t  -> case pts of+                            x:pts'-> do+                                printStringAt (pos x) "::"+                                exactPC t+                                return pts'+                            _ -> errorEP "ExactP: Decl: PatBind is given too few srcInfoPoints"+        exactPC rhs+        maybeEP (\bs -> printStringAt (pos (head pts)) "where" >> exactPC bs) mbs+    ForImp       l cc msf mstr n t   ->+        case srcInfoPoints l of+         a:b:pts -> do+            printString "foreign"+            printStringAt (pos b) "import"+            exactPC cc+            maybeEP exactPC msf+            pts <- case mstr of+                      Nothing -> return pts+                      Just str -> case pts of+                                   x:pts' -> do+                                      printStringAt (pos x) (show str)+                                      return pts'+                                   _ -> errorEP "ExactP: Decl: ForImp is given too few srcInfoPoints"+            case pts of+             y:_ -> do+                exactPC n+                printStringAt (pos y) "::"+                exactPC t+             _ -> errorEP "ExactP: Decl: ForImp is given too few srcInfoPoints"+         _ -> errorEP "ExactP: Decl: ForImp is given too few srcInfoPoints"+    ForExp       l cc mstr n t      ->+        case srcInfoPoints l of+         a:b:pts -> do+            printString "foreign"+            printStringAt (pos b) "export"+            exactPC cc+            pts <- case mstr of+                      Nothing -> return pts+                      Just str -> case pts of+                                   x:pts' -> do+                                      printStringAt (pos x) (show str)+                                      return pts'+                                   _ -> errorEP "ExactP: Decl: ForExp is given too few srcInfoPoints"+            case pts of+             y:_ -> do+                exactPC n+                printStringAt (pos y) "::"+                exactPC t+             _ -> errorEP "ExactP: Decl: ForExp is given too few srcInfoPoints"+         _ -> errorEP "ExactP: Decl: ForExp is given too few srcInfoPoints"+    RulePragmaDecl   l rs   ->+        case srcInfoPoints l of+         [a,b] -> do+            printString "{-# RULES"+            mapM_ exactPC rs+            printStringAt (pos b) "#-}"+         _ -> errorEP "ExactP: Decl: RulePragmaDecl is given too few srcInfoPoints"+    DeprPragmaDecl   l nstrs ->+        case srcInfoPoints l of+         a:pts -> do+            printString "{-# DEPRECATED"+            printWarndeprs (map pos (init pts)) nstrs+            printStringAt (pos (last pts)) "#-}"+         _ -> errorEP "ExactP: Decl: DeprPragmaDecl is given too few srcInfoPoints"+    WarnPragmaDecl   l nstrs ->+        case srcInfoPoints l of+         a:pts -> do+            printString "{-# WARNING"+            printWarndeprs (map pos (init pts)) nstrs+            printStringAt (pos (last pts)) "#-}"+         _ -> errorEP "ExactP: Decl: WarnPragmaDecl is given too few srcInfoPoints"+    InlineSig        l inl mact qn    ->+        case srcInfoPoints l of+         [a,b] -> do+            printString $ if inl then "{-# INLINE" else "{-# NOINLINE"+            maybeEP exactPC mact+            exactPC qn+            printStringAt (pos b) "#-}"+         _ -> errorEP "ExactP: Decl: InlineSig is given wrong number of srcInfoPoints"+    InlineConlikeSig l mact qn    ->+        case srcInfoPoints l of+         [a,b] -> do+            printString "{-# INLINE_CONLIKE"+            maybeEP exactPC mact+            exactPC qn+            printStringAt (pos b) "#-}"+         _ -> errorEP "ExactP: Decl: InlineConlikeSig is given wrong number of srcInfoPoints"+    SpecSig          l mact qn ts ->+        case srcInfoPoints l of+         a:pts -> do+            printString "{-# SPECIALISE"+            maybeEP exactPC mact+            exactPC qn+            printInterleaved (zip pts ("::" : replicate (length pts - 2) "," ++ ["#-}"])) ts+         _ -> errorEP "ExactP: Decl: SpecSig is given too few srcInfoPoints"+    SpecInlineSig    l b mact qn ts ->+        case srcInfoPoints l of+         a:pts -> do+            printString $ "{-# SPECIALISE " ++ if b then "INLINE" else "NOINLINE"+            maybeEP exactPC mact+            exactPC qn+            printInterleaved (zip pts ("::" : replicate (length pts - 2) "," ++ ["#-}"])) ts+         _ -> errorEP "ExactP: Decl: SpecInlineSig is given too few srcInfoPoints"+    InstSig          l mctxt ih     ->+        case srcInfoPoints l of+         [a,b,c] -> do+            printString $ "{-# SPECIALISE"+            printStringAt (pos b) "instance"+            maybeEP exactPC mctxt+            exactPC ih+            printStringAt (pos c) "#-}"+         _ -> errorEP "ExactP: Decl: InstSig is given wrong number of srcInfoPoints"+    AnnPragma       l ann       ->+        case srcInfoPoints l of+         [a,b] -> do+            printString $ "{-# ANN"+            exactPC ann+            printStringAt (pos b) "#-}"+         _ -> errorEP "ExactP: Decl: AnnPragma is given wrong number of srcInfoPoints"+++instance ExactP Annotation where+    exactP ann = case ann of+        Ann     l n e   -> do+            exactP n+            exactPC e+        TypeAnn l n e   -> do+            printString "type"+            exactPC n+            exactPC e+        ModuleAnn l e   -> do+            printString "module"+            exactPC e++printWarndeprs :: [Pos] -> [([Name SrcSpanInfo], String)] -> EP ()+printWarndeprs _ [] = return ()+printWarndeprs ps ((ns,str):nsts) = printWd ps ns str nsts+  where printWd :: [Pos] -> [Name SrcSpanInfo] -> String -> [([Name SrcSpanInfo], String)] -> EP ()+        printWd (p:ps) []  str nsts = printStringAt p (show str) >> printWarndeprs ps nsts+        printWd ps     [n] str nsts = exactPC n >> printWd ps [] str nsts+        printWd (p:ps) (n:ns) str nsts = exactPC n >> printStringAt p "," >> printWd ps ns str nsts+++sepFunBinds :: [Decl SrcSpanInfo] -> [Decl SrcSpanInfo]+sepFunBinds [] = []+sepFunBinds (FunBind _ ms:ds) = map (\m -> FunBind (ann m) [m]) ms ++ sepFunBinds ds+sepFunBinds (d:ds) = d : sepFunBinds ds++sepClassFunBinds :: [ClassDecl SrcSpanInfo] -> [ClassDecl SrcSpanInfo]+sepClassFunBinds [] = []+sepClassFunBinds (ClsDecl _ (FunBind _ ms):ds) = map (\m -> ClsDecl (ann m) $ FunBind (ann m) [m]) ms ++ sepClassFunBinds ds+sepClassFunBinds (d:ds) = d : sepClassFunBinds ds++sepInstFunBinds :: [InstDecl SrcSpanInfo] -> [InstDecl SrcSpanInfo]+sepInstFunBinds [] = []+sepInstFunBinds (InsDecl _ (FunBind _ ms):ds) = map (\m -> InsDecl (ann m) $ FunBind (ann m) [m]) ms ++ sepInstFunBinds ds+sepInstFunBinds (d:ds) = d : sepInstFunBinds ds++instance ExactP DeclHead where+  exactP dh = case dh of+    DHead l n tvs       -> exactP n >> mapM_ exactPC tvs+    DHInfix l tva n tvb -> exactP tva >> epInfixName n >> exactPC tvb+    DHParen l dh        ->+        case srcInfoPoints l of+         [_,b] -> printString "(" >> exactPC dh >> printStringAt (pos b) ")"+         _ -> errorEP "ExactP: DeclHead: DeclParen is given wrong number of srcInfoPoints"++instance ExactP InstHead where+  exactP ih = case ih of+    IHead l qn ts       -> exactP qn >> mapM_ exactPC ts+    IHInfix l ta qn tb  -> exactP ta >> epInfixQName qn >> exactPC tb+    IHParen l ih        ->+        case srcInfoPoints l of+         [_,b] -> printString "(" >> exactPC ih >> printStringAt (pos b) ")"+         _ -> errorEP "ExactP: InstHead: IHParen is given wrong number of srcInfoPoints"++instance ExactP TyVarBind where+  exactP (KindedVar   l n k) =+        case srcInfoPoints l of+         [a,b,c] -> do+            printString "("+            exactPC n+            printStringAt (pos b) "::"+            exactPC k+            printStringAt (pos c) ")"+         _ -> errorEP "ExactP: TyVarBind: KindedVar is given wrong number of srcInfoPoints"+  exactP (UnkindedVar l n) = exactP n++instance ExactP Kind where+  exactP kd = case kd of+    KindStar  l     -> printString "*"+    KindBang  l     -> printString "!"+    KindFn    l k1 k2 ->+        case srcInfoPoints l of+         [a] -> do+            exactP k1+            printStringAt (pos a) "->"+            exactPC k2+         _ -> errorEP "ExactP: Kind: KindFn is given wrong number of srcInfoPoints"+    KindParen l kd  -> do+        case srcInfoPoints l of+         [a,b] -> do+            printString "("+            exactPC kd+            printStringAt (pos b) ")"+         _ -> errorEP "ExactP: Kind: KindParen is given wrong number of srcInfoPoints"+    KindVar l n     -> exactP n++instance ExactP Type where+  exactP t = case t of+    TyForall l mtvs mctxt t -> do+        let pts = srcInfoPoints l+        pts <- case mtvs of+                Nothing -> return pts+                Just tvs ->+                    case pts of+                     a:b:pts' -> do+                        printString "forall"+                        mapM_ exactPC tvs+                        printStringAt (pos b) "."+                        return pts'+                     _ -> errorEP "ExactP: Type: TyForall is given too few srcInfoPoints"+        maybeEP exactPC mctxt+        exactPC t+    TyFun   l t1 t2 -> do+        case srcInfoPoints l of+         [a] -> do+            exactP t1+            printStringAt (pos a) "->"+            exactPC t2+         _ -> errorEP "ExactP: Type: TyFun is given wrong number of srcInfoPoints"+    TyTuple l bx ts -> do+        case bx of+          Boxed   -> parenList (srcInfoPoints l) ts+          Unboxed -> parenHashList (srcInfoPoints l) ts+    TyList  l t     -> do+        case srcInfoPoints l of+         [a,b] -> do+            printString "["+            exactPC t+            printStringAt (pos b) "]"+         _ -> errorEP "ExactP: Type: TyList is given wrong number of srcInfoPoints"+    TyApp   l t1 t2 -> exactP t1 >> exactPC t2+    TyVar   l n     -> exactP n+    TyCon   l qn    -> exactP qn+    TyParen l t     -> do+        case srcInfoPoints l of+         [a,b] -> do+            printString "("+            exactPC t+            printStringAt (pos b) ")"+         _ -> errorEP "ExactP: Type: TyParen is given wrong number of srcInfoPoints"+    TyInfix l t1 qn t2 -> exactP t1 >> epInfixQName qn >> exactPC t2+    TyKind  l t kd -> do+        case srcInfoPoints l of+         [a,b,c] -> do+            printString "("+            exactPC t+            printStringAt (pos b) "::"+            exactPC kd+            printStringAt (pos c) ")"+         _ -> errorEP "ExactP: Type: TyKind is given wrong number of srcInfoPoints"++instance ExactP Context where+  exactP ctxt = do+    printContext ctxt+    printStringAt (pos . last . srcInfoPoints . ann $ ctxt) "=>"++printContext ctxt = do+    let l = ann ctxt+        pts = init $ srcInfoPoints l+    case ctxt of+     CxParen l ctxt ->+        case pts of+         [a,b] -> do+            printStringAt (pos a) "("+            printContext ctxt+            printStringAt (pos b) ")"+         _ -> errorEP "ExactP: Context: CxParen is given wrong number of srcInfoPoints"+     CxSingle l asst -> exactP asst+     CxEmpty l ->+        case pts of+         [a,b] -> do+            printStringAt (pos a) "("+            printStringAt (pos b) ")"+         _ -> errorEP "ExactP: Context: CxEmpty is given wrong number of srcInfoPoints"+     CxTuple l assts -> parenList pts assts+++instance ExactP Asst where+  exactP asst = case asst of+    ClassA l qn ts -> exactP qn >> mapM_ exactPC ts+    InfixA l ta qn tb -> exactP ta >> epInfixQName qn >> exactPC tb+    IParam l ipn t    ->+        case srcInfoPoints l of+         [a] -> do+            exactP ipn+            printStringAt (pos a) "::"+            exactPC t+         _ -> errorEP "ExactP: Asst: IParam is given wrong number of srcInfoPoints"+    EqualP l t1 t2  ->+        case srcInfoPoints l of+         [a] -> do+            exactP t1+            printStringAt (pos a) "~"+            exactPC t2++instance ExactP Deriving where+  exactP (Deriving l ihs) =+    case srcInfoPoints l of+     x:pts -> do+        printString "deriving"+        case pts of+         [] -> exactPC $ head ihs+         _  -> parenList pts ihs+     _ -> errorEP "ExactP: Deriving is given too few srcInfoPoints"++instance ExactP ClassDecl where+  exactP cdecl = case cdecl of+    ClsDecl    l d -> exactP d+    ClsDataFam l mctxt dh mk ->+        case srcInfoPoints l of+         x:pts -> do+            printString "data"+            maybeEP exactPC mctxt+            exactPC dh+            maybeEP (\kd -> printStringAt (pos (head pts)) "::" >> exactPC kd) mk+         _ -> errorEP "ExactP: ClassDecl: ClsDataFam is given too few srcInfoPoints"+    ClsTyFam   l dh mk  ->+        case srcInfoPoints l of+         x:pts -> do+            printString "type"+            exactPC dh+            maybeEP (\kd -> printStringAt (pos (head pts)) "::" >> exactPC kd) mk+         _ -> errorEP "ExactP: ClassDecl: ClsTyFam is given too few srcInfoPoints"+    ClsTyDef   l t1 t2  ->+        case srcInfoPoints l of+         a:b:pts -> do+            printString "type"+            exactPC t1+            printStringAt (pos b) "="+            exactPC t2+         _ -> errorEP "ExactP: ClassDecl: ClsTyDef is given too few srcInfoPoints"++instance ExactP InstDecl where+  exactP idecl = case idecl of+    InsDecl   l d -> exactP d+    InsType   l t1 t2 ->+        case srcInfoPoints l of+         [a,b] -> do+            printString "type"+            exactPC t1+            printStringAt (pos b) "="+            exactPC t2+    InsData   l dn t constrs mder -> do+        exactP dn+        exactPC t+        printInterleaved (zip (srcInfoPoints l) ("=": repeat "|")) constrs+        maybeEP exactPC mder+    InsGData  l dn t mk gds mder  -> do+        let pts = srcInfoPoints l+        exactP dn+        exactPC t+        pts <- case mk of+                Nothing -> return pts+                Just kd -> case pts of+                            p:pts' -> do+                                printStringAt (pos p) "::"+                                exactPC kd+                                return pts'+                            _ -> errorEP "ExactP: InstDecl: InsGData is given too few srcInfoPoints"+        case pts of+         x:_ -> do+            printStringAt (pos x) "where"+            mapM_ exactPC gds+            maybeEP exactPC mder+         _ -> errorEP "ExactP: InstDecl: InsGData is given too few srcInfoPoints"+--  InsInline l inl mact qn   -> do+--        case srcInfoPoints l of+--         [a,b] -> do+--            printString $ if inl then "{-# INLINE" else "{-# NOINLINE"+--            maybeEP exactPC mact+--            exactPC qn+--            printStringAt (pos b) "#-}"+--         _ -> errorEP "ExactP: InstDecl: InsInline is given wrong number of srcInfoPoints"++instance ExactP FunDep where+  exactP (FunDep l nxs nys) =+    case srcInfoPoints l of+     [a] -> do+        mapM_ exactPC nxs+        printStringAt (pos a) "->"+        mapM_ exactPC nys+     _ -> errorEP "ExactP: FunDep is given wrong number of srcInfoPoints"++instance ExactP QualConDecl where+  exactP (QualConDecl l mtvs mctxt cd) = do+        let pts = srcInfoPoints l+        pts <- case mtvs of+                Nothing -> return pts+                Just tvs ->+                    case pts of+                     a:b:pts' -> do+                        printString "forall"+                        mapM_ exactPC tvs+                        printStringAt (pos b) "."+                        return pts'+                     _ -> errorEP "ExactP: QualConDecl is given wrong number of srcInfoPoints"+        maybeEP exactPC mctxt+        exactPC cd++instance ExactP ConDecl where+  exactP cd = case cd of+    ConDecl l n bts -> exactP n >> mapM_ exactPC bts+    InfixConDecl l bta n btb -> exactP bta >> epInfixName n >> exactP btb+    RecDecl l n fds -> exactP n >> curlyList (srcInfoPoints l) fds++instance ExactP GadtDecl where+  exactP (GadtDecl l n t) =+    case srcInfoPoints l of+     [a] -> do+        exactP n+        printStringAt (pos a) "::"+        exactPC t+     _ -> errorEP "ExactP: GadtDecl is given wrong number of srcInfoPoints"++instance ExactP BangType where+  exactP bt = case bt of+    UnBangedTy l t  -> exactP t+    BangedTy   l t  -> printString "!" >> exactPC t+    UnpackedTy l t  ->+      case srcInfoPoints l of+       [a,b,c] -> do+          printString "{-# UNPACK"+          printStringAt (pos b) "#-}"+          printStringAt (pos c) "!"+          exactPC t+       _ -> errorEP "ExactP: BangType: UnpackedTy is given wrong number of srcInfoPoints"++instance ExactP Splice where+  exactP (IdSplice l str) = printString $ '$':str+  exactP (ParenSplice l e) =+    case srcInfoPoints l of+     [a,b] -> do+        printString "$("+        exactPC e+        printStringAt (pos b) ")"+     _ -> errorEP "ExactP: Splice: ParenSplice is given wrong number of srcInfoPoints"++instance ExactP Exp where+  exactP exp = case exp of+    Var l qn        -> exactP qn+    IPVar l ipn     -> exactP ipn+    Con l qn        -> exactP qn+    Lit l lit       -> exactP lit+    InfixApp l e1 op e2 -> exactP e1 >> exactPC op >> exactPC e2+    App l e1 e2     -> exactP e1 >> exactPC e2+    NegApp l e      -> printString "-" >> exactPC e+    Lambda l ps e   ->+        case srcInfoPoints l of+         [a,b] -> do+            printString "\\"+            mapM_ exactPC ps+            printStringAt (pos b) "->"+            exactPC e+         _ -> errorEP "ExactP: Exp: Lambda is given wrong number of srcInfoPoints"+    Let l bs e      ->+        case srcInfoPoints l of+         [a,b] -> do+            printString "let"+            exactPC bs+            printStringAt (pos b) "in"+            exactPC e+         _ -> errorEP "ExactP: Exp: Let is given wrong number of srcInfoPoints"+    If l ec et ee   -> -- traceShow (srcInfoPoints l) $ do+        -- First we need to sort out if there are any optional+        -- semicolons hiding among the srcInfoPoints.+        case srcInfoPoints l of+         (pIf:b:c:rest) -> do+            let (mpSemi1,pThen,rest2) =+                           if snd (spanSize b) == 4 -- this is "then", not a semi+                            then (Nothing, b, c:rest)+                            else (Just b, c, rest)+            case rest2 of+              (c:rest3) -> do+                let (mpSemi2,rest4) = if snd (spanSize c) == 4 -- this is "else", not a semi+                                       then (Nothing, rest2)+                                       else (Just c, rest3)+                case rest4 of+                  [pElse] -> do+                    -- real work starts here:+                    printString "if"+                    exactPC ec+                    maybeEP printSemi  mpSemi1+                    printStringAt (pos pThen) "then"+                    exactPC et+                    maybeEP printSemi mpSemi2+                    printStringAt (pos pElse) "else"+                    exactPC ee+                  [] -> errorEP "ExactP: Exp: If is given too few srcInfoPoints"+                  _  -> errorEP "ExactP: Exp: If is given too many srcInfoPoints"+              _ -> errorEP "ExactP: Exp: If is given too few srcInfoPoints"++         _ -> errorEP "ExactP: Exp: If is given too few srcInfoPoints"+    Case l e alts   ->+        case srcInfoPoints l of+         a:b:pts -> do+            printString "case"+            exactPC e+            printStringAt (pos b) "of"+            layoutList pts alts+         _ -> errorEP "ExactP: Exp: Case is given too few srcInfoPoints"+    Do l stmts      ->+        case srcInfoPoints l of+         a:pts -> do+            printString "do"+            layoutList pts stmts+         _ -> errorEP "ExactP: Exp: Do is given too few srcInfoPoints"+    MDo l stmts     ->+        case srcInfoPoints l of+         a:pts -> do+            printString "mdo"+            layoutList pts stmts+         _ -> errorEP "ExactP: Exp: Mdo is given wrong number of srcInfoPoints"+    Tuple l bx es   ->+        case bx of+          Boxed   -> parenList (srcInfoPoints l) es+          Unboxed -> parenHashList (srcInfoPoints l) es+    TupleSection l bx mexps -> do+        let pts = srcInfoPoints l+            (o, e) = case bx of Boxed -> ("(", ")"); Unboxed -> ("(#", "#)")+        printSeq $ interleave (zip (map pos $ init pts) (map printString (o: repeat ",")) ++ [(pos $ last pts, printString e)])+                              (map (maybe (0,0) (pos . ann) &&& maybeEP exactPC) mexps)+    List l es               -> squareList (srcInfoPoints l) es+    Paren l p               -> parenList (srcInfoPoints l) [p]+    LeftSection l e qop     ->+        case srcInfoPoints l of+         [a,b] -> do+            printString "("+            exactPC e+            exactPC qop+            printStringAt (pos b) ")"+         _ -> errorEP "ExactP: Exp: LeftSection is given wrong number of srcInfoPoints"+    RightSection l qop e    ->+        case srcInfoPoints l of+         [a,b] -> do+            printString "("+            exactPC qop+            exactPC e+            printStringAt (pos b) ")"+         _ -> errorEP "ExactP: Exp: RightSection is given wrong number of srcInfoPoints"+    RecConstr l qn fups     -> do+        let pts = srcInfoPoints l+        exactP qn+        curlyList pts fups+    RecUpdate l e fups      -> do+        let pts = srcInfoPoints l+        exactP e+        curlyList pts fups+    EnumFrom l e            ->+        case srcInfoPoints l of+         [a,b,c] -> do+            printString "["+            exactPC e+            printStringAt (pos b) ".."+            printStringAt (pos c) "]"+         _ -> errorEP "ExactP: Exp: EnumFrom is given wrong number of srcInfoPoints"+    EnumFromTo l e1 e2      ->+        case srcInfoPoints l of+         [a,b,c] -> do+            printString "["+            exactPC e1+            printStringAt (pos b) ".."+            exactPC e2+            printStringAt (pos c) "]"+         _ -> errorEP "ExactP: Exp: EnumFromTo is given wrong number of srcInfoPoints"+    EnumFromThen l e1 e2    ->+        case srcInfoPoints l of+         [a,b,c,d] -> do+            printString "["+            exactPC e1+            printStringAt (pos b) ","+            exactPC e2+            printStringAt (pos c) ".."+            printStringAt (pos d) "]"+         _ -> errorEP "ExactP: Exp: EnumFromThen is given wrong number of srcInfoPoints"+    EnumFromThenTo l e1 e2 e3   ->+        case srcInfoPoints l of+         [a,b,c,d] -> do+            printString "["+            exactPC e1+            printStringAt (pos b) ","+            exactPC e2+            printStringAt (pos c) ".."+            exactPC e3+            printStringAt (pos d) "]"+         _ -> errorEP "ExactP: Exp: EnumFromToThen is given wrong number of srcInfoPoints"+    ListComp l e qss            ->+        case srcInfoPoints l of+         a:pts -> do+            printString "["+            exactPC e+            bracketList ("|",",","]") pts qss+         _ -> errorEP "ExactP: Exp: ListComp is given too few srcInfoPoints"+    ParComp  l e qsss           ->+        case srcInfoPoints l of+         a:pts -> do+            let (strs, qss) = unzip $ pairUp qsss+            printString "["+            exactPC e+            printInterleaved (zip pts (strs ++ ["]"])) qss+         _ -> errorEP "ExactP: Exp: ParComp is given wrong number of srcInfoPoints"+      where pairUp [] = []+            pairUp ((a:as):xs) = ("|", a) : zip (repeat ",") as ++ pairUp xs++    ExpTypeSig l e t    ->+        case srcInfoPoints l of+         [a] -> do+            exactP e+            printStringAt (pos a) "::"+            exactPC t+         _ -> errorEP "ExactP: Exp: ExpTypeSig is given wrong number of srcInfoPoints"+    VarQuote l qn   -> do+      printString "'"+      exactPC qn+    TypQuote l qn -> do+      printString "''"+      exactPC qn+    BracketExp l br -> exactP br+    SpliceExp l sp  -> exactP sp+    QuasiQuote l name qt    -> do+        let qtLines = lines qt+        printString $ "[" ++ name ++ "|"+        sequence_ (intersperse newLine $ map printString qtLines)+        printString "|]"+    XTag l xn attrs mat es  -> do+        case srcInfoPoints l of+         [a,b,c,d,e] -> do+            printString "<"+            exactPC xn+            mapM_ exactPC attrs+            maybeEP exactPC mat+            printStringAt (pos b) ">"+            mapM_ exactPC es+            printStringAt (pos c) "</"+            printWhitespace (pos d)+            exactP xn+            printStringAt (pos e) ">"+         -- TODO: Fugly hack/duplication, should be refactored+         -- For the case when there's an optional semicolon+         [a,b,semi,c,d,e] -> do+            printString "<"+            exactPC xn+            mapM_ exactPC attrs+            maybeEP exactPC mat+            printStringAt (pos b) ">"+            mapM_ exactPC es+            printSemi semi+            printStringAt (pos c) "</"+            printWhitespace (pos d)+            exactP xn+            printStringAt (pos e) ">"+         _ -> errorEP "ExactP: Exp: XTag is given wrong number of srcInfoPoints"+    XETag l xn attrs mat    ->+        case srcInfoPoints l of+         [a,b] -> do+            printString "<"+            exactPC xn+            mapM_ exactPC attrs+            maybeEP exactPC mat+            printStringAt (pos b) "/>"+         _ -> errorEP "ExactP: Exp: XETag is given wrong number of srcInfoPoints"+    XPcdata l str   -> do+        let strLines = lines str+        sequence_ (intersperse newLine $ map printString strLines)+    XExpTag l e     ->+        case srcInfoPoints l of+         [a,b] -> do+            printString "<%"+            exactPC e+            printStringAt (pos b) "%>"+         _ -> errorEP "ExactP: Exp: XExpTag is given wrong number of srcInfoPoints"+    XChildTag l es  ->+        case srcInfoPoints l of+         [a,b,c] -> do+            printString "<%>"+            mapM_ exactPC es+            printStringAt (pos b) "</"+            printStringAt (pos c) "%>"+         -- Ugly duplication for when there's an optional semi+         [a,semi,b,c] -> do+            printString "<%>"+            mapM_ exactPC es+            printSemi semi+            printStringAt (pos b) "</"+            printStringAt (pos c) "%>"+         _ -> errorEP "ExactP: Exp: XChildTag is given wrong number of srcInfoPoints"+    CorePragma l      str e         ->+        case srcInfoPoints l of+         [a,b] -> do+            printString $ "{-# CORE " ++ show str+            printStringAt (pos b) "#-}"+            exactPC e+         _ -> errorEP "ExactP: Exp: CorePragma is given wrong number of srcInfoPoints"+    SCCPragma  l      str e         ->+        case srcInfoPoints l of+         [a,b] -> do+            printString $ "{-# SCC " ++ show str+            printStringAt (pos b) "#-}"+            exactPC e+         _ -> errorEP "ExactP: Exp: SCCPragma is given wrong number of srcInfoPoints"+    GenPragma  l      str (i1,i2) (i3,i4) e -> do+        printStrs $ zip (srcInfoPoints l) ["{-# GENERATED", show str, show i1, ":", show i2, "-", show i3, ":", show i4, "#-}"]+        exactPC e+    Proc            l p e   ->+        case srcInfoPoints l of+         [a,b] -> do+            printString "proc"+            exactPC p+            printStringAt (pos b) "->"+            exactPC e+         _ -> errorEP "ExactP: Exp: Proc is given wrong number of srcInfoPoints"+    LeftArrApp      l e1 e2 ->+        case srcInfoPoints l of+         [a] -> do+            exactP e1+            printStringAt (pos a) "-<"+            exactPC e2+         _ -> errorEP "ExactP: Exp: LeftArrApp is given wrong number of srcInfoPoints"+    RightArrApp     l e1 e2 -> do+        case srcInfoPoints l of+         [a] -> do+            exactP e1+            printStringAt (pos a) ">-"+            exactPC e2+         _ -> errorEP "ExactP: Exp: RightArrApp is given wrong number of srcInfoPoints"+    LeftArrHighApp  l e1 e2 -> do+        case srcInfoPoints l of+         [a] -> do+            exactP e1+            printStringAt (pos a) "-<<"+            exactPC e2+         _ -> errorEP "ExactP: Exp: LeftArrHighApp is given wrong number of srcInfoPoints"+    RightArrHighApp l e1 e2 -> do+        case srcInfoPoints l of+         [a] -> do+            exactP e1+            printStringAt (pos a) ">>-"+            exactPC e2+         _ -> errorEP "ExactP: Exp: RightArrHighApp is given wrong number of srcInfoPoints"++instance ExactP FieldUpdate where+  exactP fup = case fup of+    FieldUpdate l qn e  -> do+      case srcInfoPoints l of+       [a] -> do+          exactP qn+          printStringAt (pos a) "="+          exactPC e+       _ -> errorEP "ExactP: FieldUpdate is given wrong number of srcInfoPoints"+    FieldPun l n    -> exactP n+    FieldWildcard l -> printString ".."++instance ExactP Stmt where+  exactP stmt = case stmt of+    Generator l p e ->+      case srcInfoPoints l of+       [a] -> do+          exactP p+          printStringAt (pos a) "<-"+          exactPC e+       _ -> errorEP "ExactP: Stmt: Generator is given wrong number of srcInfoPoints"+    Qualifier l e -> exactP e+    LetStmt l bds   -> do+      printString "let"+      exactPC bds+    RecStmt l ss    ->+      case srcInfoPoints l of+       a:pts -> do+          printString "rec"+          layoutList pts ss+       _ -> errorEP "ExactP: Stmt: RecStmt is given too few srcInfoPoints"++instance ExactP QualStmt where+  exactP qstmt = case qstmt of+    QualStmt     l stmt -> exactP stmt+    ThenTrans    l e    -> printString "then" >> exactPC e+    ThenBy       l e1 e2    -> do+        case srcInfoPoints l of+         [a,b] -> do+            printString "then"+            exactPC e1+            printStringAt (pos b) "by"+            exactPC e2+         _ -> errorEP "ExactP: QualStmt: ThenBy is given wrong number of srcInfoPoints"+    GroupBy      l e        -> do+        printStrs $ zip (srcInfoPoints l) ["then","group","by"]+        exactPC e+    GroupUsing   l e        -> do+        printStrs $ zip (srcInfoPoints l) ["then","group","using"]+        exactPC e+    GroupByUsing l e1 e2    -> do+        let pts = srcInfoPoints l+        printStrs $ zip (init pts) ["then","group","by"]+        exactPC e1+        printStringAt (pos (last pts)) "using"+        exactPC e2++instance ExactP Bracket where+  exactP br = case br of+    ExpBracket l e  ->+        case srcInfoPoints l of+         [a,b] -> do+            printString "[|"+            exactPC e+            printStringAt (pos b) "|]"+         _ -> errorEP "ExactP: Bracket: ExpBracket is given wrong number of srcInfoPoints"+    PatBracket l p  ->+        case srcInfoPoints l of+         [a,b] -> do+            printString "[p|"+            exactPC p+            printStringAt (pos b) "|]"+         _ -> errorEP "ExactP: Bracket: PatBracket is given wrong number of srcInfoPoints"+    TypeBracket l t  -> do+        case srcInfoPoints l of+         [a,b] -> do+            printString "[t|"+            exactPC t+            printStringAt (pos b) "|]"+         _ -> errorEP "ExactP: Bracket: TypeBracket is given wrong number of srcInfoPoints"+    DeclBracket l ds ->+        case srcInfoPoints l of+         a:pts -> do+            printString "[d|"+            layoutList (init pts) (sepFunBinds ds)+            printStringAt (pos (last pts)) "|]"+         _ -> errorEP "ExactP: Bracket: DeclBracket is given too few srcInfoPoints"++instance ExactP XAttr where+  exactP (XAttr l xn e) =+    case srcInfoPoints l of+     [a] -> do+        exactP xn+        printStringAt (pos a) "="+        exactPC e+     _ -> errorEP "ExactP: XAttr is given wrong number of srcInfoPoints"++instance ExactP Alt where+  exactP (Alt l p galts mbs) = do+    exactP p+    exactPC galts+    maybeEP (\bs -> printStringAt (pos (head (srcInfoPoints l))) "where" >> exactPC bs) mbs++instance ExactP GuardedAlts where+  exactP (UnGuardedAlt l e) = printString "->" >> exactPC e+  exactP (GuardedAlts  l galts) = mapM_ exactPC galts++instance ExactP GuardedAlt where+  exactP (GuardedAlt l stmts e) = do+    bracketList ("|",",","->") (srcInfoPoints l) stmts+    exactPC e++instance ExactP Match where+  exactP (Match l n ps rhs mbinds) = do+    let pts = srcInfoPoints l+        len = length pts+        pars = len `div` 2+        (oPars,cParsWh) = splitAt pars pts+        (cPars,whPt) = splitAt pars cParsWh    -- whPt is either singleton or empty+    printStrs (zip oPars (repeat "("))+    exactPC n+    printStreams (zip (map pos cPars) (repeat $ printString ")")) (map (pos . ann &&& exactPC) ps)+    exactPC rhs+    maybeEP (\bds -> printStringAt (pos (head pts)) "where" >> exactPC bds) mbinds+  exactP (InfixMatch l a n bs rhs mbinds) = do+    let pts = srcInfoPoints l+        len = length pts+        pars = len `div` 2+        (oPars,cParsWh) = splitAt pars pts+        (cPars,whPt) = splitAt pars cParsWh    -- whPt is either singleton or empty+    printStrs (zip oPars (repeat "("))+    exactPC a+    epInfixName n+    printInterleaved' (zip cPars (repeat ")")) bs+    exactPC rhs+    maybeEP (\bds -> printStringAt (pos (head whPt)) "where" >> exactPC bds) mbinds++instance ExactP Rhs where+  exactP (UnGuardedRhs l e) = printString "=" >> exactPC e+  exactP (GuardedRhss  l grhss) = mapM_ exactPC grhss++instance ExactP GuardedRhs where+  exactP (GuardedRhs l ss e) =+    case srcInfoPoints l of+     a:pts -> do+        printString "|"+        printInterleaved' (zip (init pts) (repeat ",") ++ [(last pts, "=")]) ss+        exactPC e+     _ -> errorEP "ExactP: GuardedRhs is given wrong number of srcInfoPoints"++instance ExactP Pat where+  exactP pat = case pat of+    PVar l n    -> exactP n+    PLit l lit  -> exactP lit+    PNeg l p    -> printString "-" >> exactPC p+    PNPlusK l n k   ->+        case srcInfoPoints l of+         [a,b] -> do+            exactP n+            printStringAt (pos a) "+"+            printStringAt (pos b) (show k)+         _ -> errorEP "ExactP: Pat: PNPlusK is given wrong number of srcInfoPoints"+    PInfixApp l pa qn pb -> exactP pa >> epInfixQName qn >> exactPC pb+    PApp l qn ps    -> exactP qn >> mapM_ exactPC ps+    PTuple l bx ps ->+        case bx of+          Boxed   -> parenList (srcInfoPoints l) ps+          Unboxed -> parenHashList (srcInfoPoints l) ps+    PList l ps  -> squareList (srcInfoPoints l) ps+    PParen l p  -> parenList (srcInfoPoints l) [p]+    PRec l qn pfs   -> exactP qn >> curlyList (srcInfoPoints l) pfs+    PAsPat l n p    ->+        case srcInfoPoints l of+         [a] -> do+            exactP n+            printStringAt (pos a) "@"+            exactPC p+         _ -> errorEP "ExactP: Pat: PAsPat is given wrong number of srcInfoPoints"+    PWildCard l -> printString "_"+    PIrrPat l p -> printString "~" >> exactPC p+    PatTypeSig l p t ->+        case srcInfoPoints l of+         [a] -> do+            exactP p+            printStringAt (pos a) "::"+            exactPC t+         _ -> errorEP "ExactP: Pat: PatTypeSig is given wrong number of srcInfoPoints"+    PViewPat l e p ->+        case srcInfoPoints l of+         [a] -> do+            exactP e+            printStringAt (pos a) "->"+            exactPC p+         _ -> errorEP "ExactP: Pat: PViewPat is given wrong number of srcInfoPoints"+    PRPat l rps -> squareList (srcInfoPoints l) rps+    PXTag l xn attrs mat ps ->+        case srcInfoPoints l of+         [a,b,c,d,e] -> do+            printString "<"+            exactPC xn+            mapM_ exactPC attrs+            maybeEP exactPC mat+            printStringAt (pos b) ">"+            mapM_ exactPC ps+            printStringAt (pos c) "</"+            printWhitespace (pos d)+            exactP xn+            printStringAt (pos e) ">"+         -- Optional semi+         [a,b,semi,c,d,e] -> do+            printString "<"+            exactPC xn+            mapM_ exactPC attrs+            maybeEP exactPC mat+            printStringAt (pos b) ">"+            mapM_ exactPC ps+            printSemi semi+            printStringAt (pos c) "</"+            printWhitespace (pos d)+            exactP xn+            printStringAt (pos e) ">"+         _ -> errorEP "ExactP: Pat: PXTag is given wrong number of srcInfoPoints"+    PXETag l xn attrs mat ->+        case srcInfoPoints l of+         [a,b] -> do+            printString "<"+            exactPC xn+            mapM_ exactPC attrs+            maybeEP exactPC mat+            printStringAt (pos b) "/>"+         _ -> errorEP "ExactP: Pat: PXETag is given wrong number of srcInfoPoints"+    PXPcdata l str -> printString str+    PXPatTag l p   ->+        case srcInfoPoints l of+         [a,b] -> do+            printString "<%"+            exactPC p+            printString "%>"+         _ -> errorEP "ExactP: Pat: PXPatTag is given wrong number of srcInfoPoints"+    PXRPats  l rps  -> bracketList ("<[",",","]>") (srcInfoPoints l) rps+    PExplTypeArg l qn t ->+        case srcInfoPoints l of+         [a,b] -> do+            exactP qn+            printStringAt (pos a) "{|"+            exactPC t+            printStringAt (pos b) "|}"+         _ -> errorEP "ExactP: Pat: PExplTypeArg is given wrong number of srcInfoPoints"+    PQuasiQuote l name qt   -> printString $ "[$" ++ name ++ "|" ++ qt ++ "]"+    PBangPat l p    -> printString "!" >> exactPC p++instance ExactP PatField where+  exactP pf = case pf of+    PFieldPat l qn p        ->+        case srcInfoPoints l of+         [a] -> do+            exactP qn+            printStringAt (pos a) "="+            exactPC p+         _ -> errorEP "ExactP: PatField: PFieldPat is given wrong number of srcInfoPoints"+    PFieldPun l n   -> exactP n+    PFieldWildcard l -> printString ".."++instance ExactP RPat where+  exactP rpat = case rpat of+    RPOp l rp op    -> exactP rp >> exactPC op+    RPEither l r1 r2 ->+      case srcInfoPoints l of+       [a] -> do+          exactP r1+          printStringAt (pos a) "|"+          exactPC r2+       _ -> errorEP "ExactP: RPat: RPEither is given wrong number of srcInfoPoints"+    RPSeq l rps -> bracketList ("(|",",","|)") (srcInfoPoints l) rps+    RPGuard l p stmts   ->+      case srcInfoPoints l of+       a:pts -> do+          printString "(|"+          exactPC p+          bracketList ("|",",","|)") pts stmts+       _ -> errorEP "ExactP: RPat: RPGuard is given wrong number of srcInfoPoints"+    RPCAs l n rp    ->+      case srcInfoPoints l of+       [a] -> do+          exactP n+          printStringAt (pos a) "@:"+          exactPC rp+       _ -> errorEP "ExactP: RPat: RPCAs is given wrong number of srcInfoPoints"+    RPAs l n rp     ->+      case srcInfoPoints l of+       [a] -> do+          exactP n+          printStringAt (pos a) "@"+          exactPC rp+       _ -> errorEP "ExactP: RPat: RPAs is given wrong number of srcInfoPoints"+    RPParen l rp    -> do+      parenList (srcInfoPoints l) [rp]+    RPPat l p   -> exactP p++instance ExactP RPatOp where+  exactP rop = printString $ case rop of+    RPStar  l  -> "*"+    RPStarG l  -> "*!"+    RPPlus  l  -> "+"+    RPPlusG l  -> "+!"+    RPOpt   l  -> "?"+    RPOptG  l  -> "?!"++instance ExactP PXAttr where+  exactP (PXAttr l xn p) =+    case srcInfoPoints l of+     [a] -> do+        exactP xn+        printStringAt (pos a) "="+        exactPC p+     _ -> errorEP "ExactP: PXAttr is given wrong number of srcInfoPoints"++instance ExactP XName where+  exactP xn = case xn of+    XName l name -> printString name+    XDomName l dom name ->+        case srcInfoPoints l of+         [a,b,c] -> do+            printString dom+            printStringAt (pos b) ":"+            printStringAt (pos c) name+         _ -> errorEP "ExactP: XName: XDomName is given wrong number of srcInfoPoints"++instance ExactP Binds where+  exactP (BDecls  l ds)  = layoutList (srcInfoPoints l) (sepFunBinds ds)+  exactP (IPBinds l ips) = layoutList (srcInfoPoints l) ips++instance ExactP CallConv where+  exactP (StdCall   _) = printString "stdcall"+  exactP (CCall     _) = printString "ccall"+  exactP (CPlusPlus _) = printString "cplusplus"+  exactP (DotNet    _) = printString "dotnet"+  exactP (Jvm       _) = printString "jvm"+  exactP (Js        _) = printString "js"+  exactP (CApi      _) = printString "capi"++instance ExactP Safety where+  exactP (PlayRisky _) = printString "unsafe"+  exactP (PlaySafe _ b) = printString $ if b then "threadsafe" else "safe"+  exactP (PlayInterruptible _) = printString "interruptible"++instance ExactP Rule where+  exactP (Rule l str mact mrvs e1 e2) =+    case srcInfoPoints l of+     a:pts -> do+        printString (show str)+        maybeEP exactP mact+        pts <- case mrvs of+                Nothing -> return pts+                Just rvs ->+                    case pts of+                     a:b:pts' -> do+                        printStringAt (pos a) "forall"+                        mapM_ exactPC rvs+                        printStringAt (pos b) "."+                        return pts'+                     _ -> errorEP "ExactP: Rule is given too few srcInfoPoints"+        case pts of+         [x] -> do+            exactPC e1+            printStringAt (pos x) "="+            exactPC e2+         _ -> errorEP "ExactP: Rule is given wrong number of srcInfoPoints"+     _ -> errorEP "ExactP: Rule is given too few srcInfoPoints"++instance ExactP RuleVar where+  exactP (TypedRuleVar l n t) = do+        case srcInfoPoints l of+         [a,b,c] -> do+            printString "("+            exactPC n+            printStringAt (pos b) "::"+            exactPC t+            printStringAt (pos c) ")"+         _ -> errorEP "ExactP: RuleVar: TypedRuleVar is given wrong number of srcInfoPoints"+  exactP (RuleVar l n) = exactP n++instance ExactP Activation where+  exactP (ActiveFrom   l i) =+    printPoints l ["[", show i, "]"]+  exactP (ActiveUntil  l i) =+    printPoints l ["[", "~", show i, "]"]++instance ExactP FieldDecl where+  exactP (FieldDecl l ns bt) = do+    let pts = srcInfoPoints l+    printInterleaved' (zip (init pts) (repeat ",") ++ [(last pts, "::")]) ns+    exactPC bt++instance ExactP IPBind where+  exactP (IPBind l ipn e) = do+    case srcInfoPoints l of+     [a] -> do+        exactP ipn+        printStringAt (pos a) "="+        exactPC e+     _ -> errorEP "ExactP: IPBind is given wrong number of srcInfoPoints"
src/Language/Haskell/Exts/Annotated/Fixity.hs view
@@ -1,344 +1,345 @@------------------------------------------------------------------------------
--- |
--- Module      :  Language.Haskell.Exts.Annotated.Fixity
--- Copyright   :  (c) Niklas Broberg 2009
--- License     :  BSD-style (see the file LICENSE.txt)
---
--- Maintainer  :  Niklas Broberg, d00nibro@chalmers.se
--- Stability   :  stable
--- Portability :  portable
---
--- Fixity information to give the parser so that infix operators can
--- be parsed properly.
---
------------------------------------------------------------------------------
-module Language.Haskell.Exts.Annotated.Fixity
-    (
-    -- * Fixity representation
-      Fixity(..)
-    -- | The following three functions all create lists of
-    --   fixities from textual representations of operators.
-    --   The intended usage is e.g.
-    --
-    -- > fixs = infixr_ 0  ["$","$!","`seq`"]
-    --
-    --   Note that the operators are expected as you would
-    --   write them infix, i.e. with ` characters surrounding
-    --   /varid/ operators, and /varsym/ operators written as is.
-    , infix_, infixl_, infixr_
-    -- ** Collections of fixities
-    , preludeFixities, baseFixities
-
-    -- * Applying fixities to an AST
-    , AppFixity(..)
-    ) where
-
-import Language.Haskell.Exts.Annotated.Syntax
-import Language.Haskell.Exts.SrcLoc
-import Language.Haskell.Exts.ParseMonad (ParseResult(..))
-
-import Language.Haskell.Exts.Fixity ( Fixity(..), infix_, infixl_, infixr_, preludeFixities, baseFixities, prefixMinusFixity )
-import qualified Language.Haskell.Exts.Syntax as S ( Assoc(..), QOp(..), Op(..), QName(..), Name(..), SpecialCon(..), ModuleName )
-import Language.Haskell.Exts.Annotated.Simplify ( sQOp, sOp, sAssoc, sQName, sModuleHead, sName )
-
-import Data.Char (isUpper)
-import Control.Monad (when, (<=<), liftM, liftM2, liftM3, liftM4)
-import Data.Traversable (mapM)
-import Prelude hiding (mapM)
-
--- | All AST elements that may include expressions which in turn may
---   need fixity tweaking will be instances of this class.
-class AppFixity ast where
-  -- | Tweak any expressions in the element to account for the
-  --   fixities given. Assumes that all operator expressions are
-  --   fully left associative chains to begin with.
-  applyFixities :: Monad m => [Fixity]      -- ^ The fixities to account for.
-                    -> ast SrcSpanInfo      -- ^ The element to tweak.
-                    -> m (ast SrcSpanInfo)  -- ^ The same element, but with operator expressions updated, or a failure.
-
-
-instance AppFixity Exp where
-  applyFixities fixs = infFix fixs <=< leafFix fixs
-    where -- This is the real meat case. We can assume a left-associative list to begin with.
-          infFix fixs (InfixApp l2 a op2 z) = do
-              e <- infFix fixs a
-              let fixup (a1,p1) (a2,p2) l1 y pre = do
-                      when (p1 == p2 && (a1 /= a2 || a1 == S.AssocNone)) -- Ambiguous infix expression!
-                           $ fail "Ambiguous infix expression"
-                      if (p1 > p2 || p1 == p2 && (a1 == S.AssocLeft || a2 == S.AssocNone)) -- Already right order
-                       then return $ InfixApp l2 e op2 z
-                       else liftM pre (infFix fixs $ InfixApp (ann y <++> ann z) y op2 z)
-              case e of
-               InfixApp l1 x op1 y -> fixup (askFixity fixs op1) (askFixity fixs op2) l1 y (InfixApp l2 x op1)
-               NegApp   l1       y -> fixup prefixMinusFixity    (askFixity fixs op2) l1 y (NegApp l2)
-               _  -> return $ InfixApp l2 e op2 z
-
-          infFix _ e = return e
-
---ambOps l = ParseFailed (getPointLoc l) $ "Ambiguous infix expression"
-
-instance AppFixity Pat where
-  applyFixities fixs = infFix fixs <=< leafFixP fixs
-    where -- This is the real meat case. We can assume a left-associative list to begin with.
-          infFix fixs (PInfixApp l2 a op2 z) = do
-              p <- infFix fixs a
-              let fixup (a1,p1) (a2,p2) l1 y pre = do
-                      when (p1 == p2 && (a1 /= a2 || a1 == S.AssocNone )) -- Ambiguous infix expression!
-                           $ fail "Ambiguous infix expression"
-                      if (p1 > p2 || p1 == p2 && (a1 == S.AssocLeft || a2 == S.AssocNone)) -- Already right order
-                       then return $ PInfixApp l2 p op2 z
-                       else liftM pre (infFix fixs $ PInfixApp (ann y <++> ann z) y op2 z)
-              case p of
-               PInfixApp l1 x op1 y -> fixup (askFixityP fixs op1) (askFixityP fixs op2) l1 y (PInfixApp l2 x op1)
-               PNeg      l1       y -> fixup prefixMinusFixity     (askFixityP fixs op2) l1 y (PNeg l2)
-               _  -> return $ PInfixApp l2 p op2 z
-
-          infFix _ p = return p
-
--- Internal: lookup associativity and precedence of an operator
-askFixity :: [Fixity] -> QOp l -> (S.Assoc, Int)
-askFixity xs k = askFix xs (f $ sQOp k) -- undefined -- \k -> askFixityP xs (f k) -- lookupWithDefault (AssocLeft, 9) (f k) mp
-    where
-        f (S.QVarOp x) = g x
-        f (S.QConOp x) = g x
-
-        g (S.Special S.Cons) = S.UnQual (S.Symbol ":")
-        g x                  = x
-
--- Same using patterns
-askFixityP :: [Fixity] -> QName l -> (S.Assoc, Int)
-askFixityP xs qn = askFix xs (g $ sQName qn)
-    where
-        g (S.Special S.Cons) = S.UnQual (S.Symbol ":")
-        g x                  = x
-        
-askFix :: [Fixity] -> S.QName -> (S.Assoc, Int)
-askFix xs = \k -> lookupWithDefault (S.AssocLeft, 9) k mp
-    where
-        lookupWithDefault def k mp = case lookup k mp of
-            Nothing -> def
-            Just x  -> x
-
-        mp = [(x,(a,p)) | Fixity a p x <- xs]
-
-
--------------------------------------------------------------------
--- Boilerplate - yuck!! Everything below here is internal stuff
-
-instance AppFixity Module where
-    applyFixities fixs (Module l mmh prs imp decls) =
-        liftM (Module l mmh prs imp) $ appFixDecls (Just mn) fixs decls
-      where (mn, _, _) = sModuleHead mmh
-    applyFixities fixs (XmlPage l mn os xn xas mexp cs) =
-        liftM3 (XmlPage l mn os xn) (fix xas) (fix mexp) (fix cs)
-      where fix xs = mapM (applyFixities fixs) xs
-    applyFixities fixs (XmlHybrid l mmh prs imp decls xn xas mexp cs) =
-        liftM4 (flip (XmlHybrid l mmh prs imp) xn) (appFixDecls (Just mn) fixs decls)
-                (fixe xas) (fixe mexp) (fixe cs)
-      where fixe xs = let extraFixs = getFixities (Just mn) decls
-                       in mapM (applyFixities (fixs++extraFixs)) xs
-            (mn, _, _) = sModuleHead mmh
-
-instance AppFixity Decl where
-    applyFixities fixs decl = case decl of
-        ClassDecl l ctxt dh deps cdecls   -> liftM (ClassDecl l ctxt dh deps) $ mapM (mapM fix) cdecls
-        InstDecl  l ctxt ih idecls        -> liftM (InstDecl  l ctxt ih)      $ mapM (mapM fix) idecls
-        SpliceDecl l spl        -> liftM (SpliceDecl l) $ fix spl
-        FunBind l matches       -> liftM (FunBind l) $ mapM fix matches
-        PatBind l p mt rhs bs   -> liftM3 (flip (PatBind l) mt) (fix p) (fix rhs) (mapM fix bs)
-        AnnPragma l ann         -> liftM (AnnPragma l) $ fix ann
-        _                       -> return decl
-      where fix x = applyFixities fixs x
-
-appFixDecls :: Monad m => Maybe S.ModuleName -> [Fixity] -> [Decl SrcSpanInfo] -> m [Decl SrcSpanInfo]
-appFixDecls mmdl fixs decls =
-    let extraFixs = getFixities mmdl decls
-     in mapM (applyFixities (fixs++extraFixs)) decls
-
-getFixities mmdl = concatMap (getFixity mmdl)
-getFixity mmdl (InfixDecl _ a mp ops) = let p = maybe 9 id mp in map (Fixity (sAssoc a) p) (concatMap g ops)
-  where g (VarOp l x) = f $ sName x
-        g (ConOp l x) = f $ sName x
-        f x = case mmdl of
-              Nothing -> [            S.UnQual x]
-              Just m  -> [S.Qual m x, S.UnQual x]
-getFixity _ _ = []
-
-instance AppFixity Annotation where
-    applyFixities fixs ann = case ann of
-        Ann     l n e   -> liftM (Ann l n) $ fix e
-        TypeAnn l n e   -> liftM (TypeAnn l n) $ fix e
-        ModuleAnn l e   -> liftM (ModuleAnn l) $ fix e
-      where fix x = applyFixities fixs x
-
-instance AppFixity ClassDecl where
-    applyFixities fixs (ClsDecl l decl) = liftM (ClsDecl l) $ applyFixities fixs decl
-    applyFixities _ cdecl = return cdecl
-
-instance AppFixity InstDecl where
-    applyFixities fixs (InsDecl l decl) = liftM (InsDecl l) $ applyFixities fixs decl
-    applyFixities _ idecl = return idecl
-
-instance AppFixity Match where
-    applyFixities fixs match = case match of
-        Match l n ps rhs bs -> liftM3 (Match l n) (mapM fix ps) (fix rhs) (mapM fix bs)
-        InfixMatch l a n ps rhs bs -> liftM4 (flip (InfixMatch l) n) (fix a) (mapM fix ps) (fix rhs) (mapM fix bs)
-      where fix x = applyFixities fixs x
-
-instance AppFixity Rhs where
-    applyFixities fixs rhs = case rhs of
-        UnGuardedRhs l e      -> liftM (UnGuardedRhs l) $ fix e
-        GuardedRhss l grhss   -> liftM (GuardedRhss l) $ mapM fix grhss
-      where fix x = applyFixities fixs x
-
-instance AppFixity GuardedRhs where
-    applyFixities fixs (GuardedRhs l stmts e) = liftM2 (GuardedRhs l) (mapM fix stmts) $ fix e
-      where fix x = applyFixities fixs x
-
-instance AppFixity PatField where
-    applyFixities fixs (PFieldPat l n p) = liftM (PFieldPat l n) $ applyFixities fixs p
-    applyFixities _ pf = return pf
-
-instance AppFixity RPat where
-    applyFixities fixs rp = case rp of
-        RPOp l rp op          -> liftM (flip (RPOp l) op) $ fix rp
-        RPEither l a b        -> liftM2 (RPEither l) (fix a) (fix b)
-        RPSeq l rps           -> liftM (RPSeq l) $ mapM fix rps
-        RPGuard l p stmts     -> liftM2 (RPGuard l) (fix p) $ mapM fix stmts
-        RPCAs l n rp          -> liftM (RPCAs l n) $ fix rp
-        RPAs l n rp           -> liftM (RPAs l n) $ fix rp
-        RPParen l rp          -> liftM (RPParen l) $ fix rp
-        RPPat l p             -> liftM (RPPat l) $ fix p
-      where fix x = applyFixities fixs x
-
-instance AppFixity PXAttr where
-    applyFixities fixs (PXAttr l n p) = liftM (PXAttr l n) $ applyFixities fixs p
-
-instance AppFixity Stmt where
-    applyFixities fixs stmt = case stmt of
-        Generator l p e       -> liftM2 (Generator l) (fix p) (fix e)
-        Qualifier l e         -> liftM (Qualifier l) $ fix e
-        LetStmt l bs          -> liftM (LetStmt l) $ fix bs    -- special behavior
-        RecStmt l stmts       -> liftM (RecStmt l) $ mapM fix stmts
-      where fix x = applyFixities fixs x
-
-instance AppFixity Binds where
-    applyFixities fixs bs = case bs of
-        BDecls l decls        -> liftM (BDecls l) $ appFixDecls Nothing fixs decls  -- special behavior
-        IPBinds l ips         -> liftM (IPBinds l) $ mapM fix ips
-      where fix x = applyFixities fixs x
-
-
-instance AppFixity IPBind where
-    applyFixities fixs (IPBind l n e) = liftM (IPBind l n) $ applyFixities fixs e
-
-instance AppFixity FieldUpdate where
-    applyFixities fixs (FieldUpdate l n e) = liftM (FieldUpdate l n) $ applyFixities fixs e
-    applyFixities _ fup = return fup
-
-instance AppFixity Alt where
-    applyFixities fixs (Alt l p galts bs) = liftM3 (Alt l) (fix p) (fix galts) (mapM fix bs)
-      where fix x = applyFixities fixs x
-
-instance AppFixity GuardedAlts where
-    applyFixities fixs galts = case galts of
-        UnGuardedAlt l e      -> liftM (UnGuardedAlt l) $ fix e
-        GuardedAlts  l galts  -> liftM (GuardedAlts l) $ mapM fix galts
-      where fix x = applyFixities fixs x
-
-instance AppFixity GuardedAlt where
-    applyFixities fixs (GuardedAlt l stmts e) = liftM2 (GuardedAlt l) (mapM fix stmts) (fix e)
-      where fix x = applyFixities fixs x
-
-instance AppFixity QualStmt where
-    applyFixities fixs qstmt = case qstmt of
-        QualStmt     l s      -> liftM (QualStmt l) $ fix s
-        ThenTrans    l e      -> liftM (ThenTrans l) $ fix e
-        ThenBy       l e1 e2  -> liftM2 (ThenBy l) (fix e1) (fix e2)
-        GroupBy      l e      -> liftM (GroupBy l) (fix e)
-        GroupUsing   l e      -> liftM (GroupUsing l) (fix e)
-        GroupByUsing l e1 e2  -> liftM2 (GroupByUsing l) (fix e1) (fix e2)
-      where fix x = applyFixities fixs x
-
-instance AppFixity Bracket where
-    applyFixities fixs br = case br of
-        ExpBracket l e    -> liftM (ExpBracket l) $ fix e
-        PatBracket l p    -> liftM (PatBracket l) $ fix p
-        DeclBracket l ds  -> liftM (DeclBracket l) $ mapM fix ds
-        _                 -> return br
-      where fix x = applyFixities fixs x
-
-instance AppFixity Splice where
-    applyFixities fixs (ParenSplice l e) = liftM (ParenSplice l) $ applyFixities fixs e
-    applyFixities _ s = return s
-
-instance AppFixity XAttr where
-    applyFixities fixs (XAttr l n e) = liftM (XAttr l n) $ applyFixities fixs e
-
-
--- the boring boilerplate stuff for expressions too
--- Recursively fixes the "leaves" of the infix chains,
--- without yet touching the chain itself. We assume all chains are
--- left-associate to begin with.
-leafFix fixs e = case e of
-    InfixApp l e1 op e2       -> liftM2 (flip (InfixApp l) op) (leafFix fixs e1) (fix e2)
-    App l e1 e2               -> liftM2 (App l) (fix e1) (fix e2)
-    NegApp l e                -> liftM (NegApp l) $ fix e
-    Lambda l pats e           -> liftM2 (Lambda l) (mapM fix pats) $ fix e
-    Let l bs e                -> liftM2 (Let l) (fix bs) $ fix e
-    If l e a b                -> liftM3 (If l) (fix e) (fix a) (fix b)
-    Case l e alts             -> liftM2 (Case l) (fix e) $ mapM fix alts
-    Do l stmts                -> liftM (Do l) $ mapM fix stmts
-    MDo l stmts               -> liftM (MDo l) $ mapM fix stmts
-    Tuple l exps              -> liftM (Tuple l) $ mapM fix exps
-    List l exps               -> liftM (List l) $ mapM fix  exps
-    Paren l e                 -> liftM (Paren l) $ fix e
-    LeftSection l e op        -> liftM (flip (LeftSection l) op) (fix e)
-    RightSection l op e       -> liftM (RightSection l op) $ fix e
-    RecConstr l n fups        -> liftM (RecConstr l n) $ mapM fix fups
-    RecUpdate l e fups        -> liftM2 (RecUpdate l) (fix e) $ mapM fix fups
-    EnumFrom l e              -> liftM (EnumFrom l) $ fix e
-    EnumFromTo l e1 e2        -> liftM2 (EnumFromTo l) (fix e1) (fix e2)
-    EnumFromThen l e1 e2      -> liftM2 (EnumFromThen l) (fix e1) (fix e2)
-    EnumFromThenTo l e1 e2 e3 -> liftM3 (EnumFromThenTo l) (fix e1) (fix e2) (fix e3)
-    ListComp l e quals        -> liftM2 (ListComp l) (fix e) $ mapM fix quals
-    ParComp  l e qualss       -> liftM2 (ParComp l) (fix e) $ mapM (mapM fix) qualss
-    ExpTypeSig l e t          -> liftM (flip (ExpTypeSig l) t) (fix e)
-    BracketExp l b            -> liftM (BracketExp l) $ fix b
-    SpliceExp l s             -> liftM (SpliceExp l) $ fix s
-    XTag l n ats mexp cs      -> liftM3 (XTag l n) (mapM fix ats) (mapM fix mexp) (mapM fix cs)
-    XETag l n ats mexp        -> liftM2 (XETag l n) (mapM fix ats) (mapM fix mexp)
-    XExpTag l e               -> liftM (XExpTag l) $ fix e
-    XChildTag l cs            -> liftM (XChildTag l) $ mapM fix cs
-    Proc l p e                -> liftM2 (Proc l) (fix p) (fix e)
-    LeftArrApp l e1 e2        -> liftM2 (LeftArrApp l) (fix e1) (fix e2)
-    RightArrApp l e1 e2       -> liftM2 (RightArrApp l) (fix e1) (fix e2)
-    LeftArrHighApp l e1 e2    -> liftM2 (LeftArrHighApp l) (fix e1) (fix e2)
-    RightArrHighApp l e1 e2   -> liftM2 (RightArrHighApp l) (fix e1) (fix e2)
-    CorePragma l s e          -> liftM (CorePragma l s) (fix e)
-    SCCPragma l s e           -> liftM (SCCPragma l s) (fix e)
-    GenPragma l s ab cd e     -> liftM (GenPragma l s ab cd) (fix e)
-
-    _                         -> return e
-  where
-    fix x = applyFixities fixs x
-
-leafFixP fixs p = case p of
-        PNeg l p                -> liftM (PNeg l) $ fix p
-        PApp l n ps             -> liftM (PApp l n) $ mapM fix ps
-        PTuple l ps             -> liftM (PTuple l) $ mapM fix ps
-        PList l ps              -> liftM (PList l) $ mapM fix ps
-        PParen l p              -> liftM (PParen l) $ fix p
-        PRec l n pfs            -> liftM (PRec l n) $ mapM fix pfs
-        PAsPat l n p            -> liftM (PAsPat l n) $ fix p
-        PIrrPat l p             -> liftM (PIrrPat l) $ fix p
-        PatTypeSig l p t        -> liftM (flip (PatTypeSig l) t) (fix p)
-        PViewPat l e p          -> liftM2 (PViewPat l) (fix e) (fix p)
-        PRPat l rps             -> liftM (PRPat l) $ mapM fix rps
-        PXTag l n ats mp ps     -> liftM3 (PXTag l n) (mapM fix ats) (mapM fix mp) (mapM fix ps)
-        PXETag l n ats mp       -> liftM2 (PXETag l n) (mapM fix ats) (mapM fix mp)
-        PXPatTag l p            -> liftM (PXPatTag l) $ fix p
-        PXRPats l rps           -> liftM (PXRPats l) $ mapM fix rps
-        PBangPat l p            -> liftM (PBangPat l) $ fix p
-        _                       -> return p
-      where fix x = applyFixities fixs x
+-----------------------------------------------------------------------------+-- |+-- Module      :  Language.Haskell.Exts.Annotated.Fixity+-- Copyright   :  (c) Niklas Broberg 2009+-- License     :  BSD-style (see the file LICENSE.txt)+--+-- Maintainer  :  Niklas Broberg, d00nibro@chalmers.se+-- Stability   :  stable+-- Portability :  portable+--+-- Fixity information to give the parser so that infix operators can+-- be parsed properly.+--+-----------------------------------------------------------------------------+module Language.Haskell.Exts.Annotated.Fixity+    (+    -- * Fixity representation+      Fixity(..)+    -- | The following three functions all create lists of+    --   fixities from textual representations of operators.+    --   The intended usage is e.g.+    --+    -- > fixs = infixr_ 0  ["$","$!","`seq`"]+    --+    --   Note that the operators are expected as you would+    --   write them infix, i.e. with ` characters surrounding+    --   /varid/ operators, and /varsym/ operators written as is.+    , infix_, infixl_, infixr_+    -- ** Collections of fixities+    , preludeFixities, baseFixities++    -- * Applying fixities to an AST+    , AppFixity(..)+    ) where++import Language.Haskell.Exts.Annotated.Syntax+import Language.Haskell.Exts.SrcLoc+import Language.Haskell.Exts.ParseMonad (ParseResult(..))++import Language.Haskell.Exts.Fixity ( Fixity(..), infix_, infixl_, infixr_, preludeFixities, baseFixities, prefixMinusFixity )+import qualified Language.Haskell.Exts.Syntax as S ( Assoc(..), QOp(..), Op(..), QName(..), Name(..), SpecialCon(..), ModuleName )+import Language.Haskell.Exts.Annotated.Simplify ( sQOp, sOp, sAssoc, sQName, sModuleHead, sName )++import Data.Char (isUpper)+import Control.Monad (when, (<=<), liftM, liftM2, liftM3, liftM4)+import Data.Traversable (mapM)+import Prelude hiding (mapM)++-- | All AST elements that may include expressions which in turn may+--   need fixity tweaking will be instances of this class.+class AppFixity ast where+  -- | Tweak any expressions in the element to account for the+  --   fixities given. Assumes that all operator expressions are+  --   fully left associative chains to begin with.+  applyFixities :: Monad m => [Fixity]      -- ^ The fixities to account for.+                    -> ast SrcSpanInfo      -- ^ The element to tweak.+                    -> m (ast SrcSpanInfo)  -- ^ The same element, but with operator expressions updated, or a failure.+++instance AppFixity Exp where+  applyFixities fixs = infFix fixs <=< leafFix fixs+    where -- This is the real meat case. We can assume a left-associative list to begin with.+          infFix fixs (InfixApp l2 a op2 z) = do+              e <- infFix fixs a+              let fixup (a1,p1) (a2,p2) l1 y pre = do+                      when (p1 == p2 && (a1 /= a2 || a1 == S.AssocNone)) -- Ambiguous infix expression!+                           $ fail "Ambiguous infix expression"+                      if (p1 > p2 || p1 == p2 && (a1 == S.AssocLeft || a2 == S.AssocNone)) -- Already right order+                       then return $ InfixApp l2 e op2 z+                       else liftM pre (infFix fixs $ InfixApp (ann y <++> ann z) y op2 z)+              case e of+               InfixApp l1 x op1 y -> fixup (askFixity fixs op1) (askFixity fixs op2) l1 y (InfixApp l2 x op1)+               NegApp   l1       y -> fixup prefixMinusFixity    (askFixity fixs op2) l1 y (NegApp l2)+               _  -> return $ InfixApp l2 e op2 z++          infFix _ e = return e++--ambOps l = ParseFailed (getPointLoc l) $ "Ambiguous infix expression"++instance AppFixity Pat where+  applyFixities fixs = infFix fixs <=< leafFixP fixs+    where -- This is the real meat case. We can assume a left-associative list to begin with.+          infFix fixs (PInfixApp l2 a op2 z) = do+              p <- infFix fixs a+              let fixup (a1,p1) (a2,p2) l1 y pre = do+                      when (p1 == p2 && (a1 /= a2 || a1 == S.AssocNone )) -- Ambiguous infix expression!+                           $ fail "Ambiguous infix expression"+                      if (p1 > p2 || p1 == p2 && (a1 == S.AssocLeft || a2 == S.AssocNone)) -- Already right order+                       then return $ PInfixApp l2 p op2 z+                       else liftM pre (infFix fixs $ PInfixApp (ann y <++> ann z) y op2 z)+              case p of+               PInfixApp l1 x op1 y -> fixup (askFixityP fixs op1) (askFixityP fixs op2) l1 y (PInfixApp l2 x op1)+               PNeg      l1       y -> fixup prefixMinusFixity     (askFixityP fixs op2) l1 y (PNeg l2)+               _  -> return $ PInfixApp l2 p op2 z++          infFix _ p = return p++-- Internal: lookup associativity and precedence of an operator+askFixity :: [Fixity] -> QOp l -> (S.Assoc, Int)+askFixity xs k = askFix xs (f $ sQOp k) -- undefined -- \k -> askFixityP xs (f k) -- lookupWithDefault (AssocLeft, 9) (f k) mp+    where+        f (S.QVarOp x) = g x+        f (S.QConOp x) = g x++        g (S.Special S.Cons) = S.UnQual (S.Symbol ":")+        g x                  = x++-- Same using patterns+askFixityP :: [Fixity] -> QName l -> (S.Assoc, Int)+askFixityP xs qn = askFix xs (g $ sQName qn)+    where+        g (S.Special S.Cons) = S.UnQual (S.Symbol ":")+        g x                  = x+        +askFix :: [Fixity] -> S.QName -> (S.Assoc, Int)+askFix xs = \k -> lookupWithDefault (S.AssocLeft, 9) k mp+    where+        lookupWithDefault def k mp = case lookup k mp of+            Nothing -> def+            Just x  -> x++        mp = [(x,(a,p)) | Fixity a p x <- xs]+++-------------------------------------------------------------------+-- Boilerplate - yuck!! Everything below here is internal stuff++instance AppFixity Module where+    applyFixities fixs (Module l mmh prs imp decls) =+        liftM (Module l mmh prs imp) $ appFixDecls (Just mn) fixs decls+      where (mn, _, _) = sModuleHead mmh+    applyFixities fixs (XmlPage l mn os xn xas mexp cs) =+        liftM3 (XmlPage l mn os xn) (fix xas) (fix mexp) (fix cs)+      where fix xs = mapM (applyFixities fixs) xs+    applyFixities fixs (XmlHybrid l mmh prs imp decls xn xas mexp cs) =+        liftM4 (flip (XmlHybrid l mmh prs imp) xn) (appFixDecls (Just mn) fixs decls)+                (fixe xas) (fixe mexp) (fixe cs)+      where fixe xs = let extraFixs = getFixities (Just mn) decls+                       in mapM (applyFixities (fixs++extraFixs)) xs+            (mn, _, _) = sModuleHead mmh++instance AppFixity Decl where+    applyFixities fixs decl = case decl of+        ClassDecl l ctxt dh deps cdecls   -> liftM (ClassDecl l ctxt dh deps) $ mapM (mapM fix) cdecls+        InstDecl  l ctxt ih idecls        -> liftM (InstDecl  l ctxt ih)      $ mapM (mapM fix) idecls+        SpliceDecl l spl        -> liftM (SpliceDecl l) $ fix spl+        FunBind l matches       -> liftM (FunBind l) $ mapM fix matches+        PatBind l p mt rhs bs   -> liftM3 (flip (PatBind l) mt) (fix p) (fix rhs) (mapM fix bs)+        AnnPragma l ann         -> liftM (AnnPragma l) $ fix ann+        _                       -> return decl+      where fix x = applyFixities fixs x++appFixDecls :: Monad m => Maybe S.ModuleName -> [Fixity] -> [Decl SrcSpanInfo] -> m [Decl SrcSpanInfo]+appFixDecls mmdl fixs decls =+    let extraFixs = getFixities mmdl decls+     in mapM (applyFixities (fixs++extraFixs)) decls++getFixities mmdl = concatMap (getFixity mmdl)+getFixity mmdl (InfixDecl _ a mp ops) = let p = maybe 9 id mp in map (Fixity (sAssoc a) p) (concatMap g ops)+  where g (VarOp l x) = f $ sName x+        g (ConOp l x) = f $ sName x+        f x = case mmdl of+              Nothing -> [            S.UnQual x]+              Just m  -> [S.Qual m x, S.UnQual x]+getFixity _ _ = []++instance AppFixity Annotation where+    applyFixities fixs ann = case ann of+        Ann     l n e   -> liftM (Ann l n) $ fix e+        TypeAnn l n e   -> liftM (TypeAnn l n) $ fix e+        ModuleAnn l e   -> liftM (ModuleAnn l) $ fix e+      where fix x = applyFixities fixs x++instance AppFixity ClassDecl where+    applyFixities fixs (ClsDecl l decl) = liftM (ClsDecl l) $ applyFixities fixs decl+    applyFixities _ cdecl = return cdecl++instance AppFixity InstDecl where+    applyFixities fixs (InsDecl l decl) = liftM (InsDecl l) $ applyFixities fixs decl+    applyFixities _ idecl = return idecl++instance AppFixity Match where+    applyFixities fixs match = case match of+        Match l n ps rhs bs -> liftM3 (Match l n) (mapM fix ps) (fix rhs) (mapM fix bs)+        InfixMatch l a n ps rhs bs -> liftM4 (flip (InfixMatch l) n) (fix a) (mapM fix ps) (fix rhs) (mapM fix bs)+      where fix x = applyFixities fixs x++instance AppFixity Rhs where+    applyFixities fixs rhs = case rhs of+        UnGuardedRhs l e      -> liftM (UnGuardedRhs l) $ fix e+        GuardedRhss l grhss   -> liftM (GuardedRhss l) $ mapM fix grhss+      where fix x = applyFixities fixs x++instance AppFixity GuardedRhs where+    applyFixities fixs (GuardedRhs l stmts e) = liftM2 (GuardedRhs l) (mapM fix stmts) $ fix e+      where fix x = applyFixities fixs x++instance AppFixity PatField where+    applyFixities fixs (PFieldPat l n p) = liftM (PFieldPat l n) $ applyFixities fixs p+    applyFixities _ pf = return pf++instance AppFixity RPat where+    applyFixities fixs rp = case rp of+        RPOp l rp op          -> liftM (flip (RPOp l) op) $ fix rp+        RPEither l a b        -> liftM2 (RPEither l) (fix a) (fix b)+        RPSeq l rps           -> liftM (RPSeq l) $ mapM fix rps+        RPGuard l p stmts     -> liftM2 (RPGuard l) (fix p) $ mapM fix stmts+        RPCAs l n rp          -> liftM (RPCAs l n) $ fix rp+        RPAs l n rp           -> liftM (RPAs l n) $ fix rp+        RPParen l rp          -> liftM (RPParen l) $ fix rp+        RPPat l p             -> liftM (RPPat l) $ fix p+      where fix x = applyFixities fixs x++instance AppFixity PXAttr where+    applyFixities fixs (PXAttr l n p) = liftM (PXAttr l n) $ applyFixities fixs p++instance AppFixity Stmt where+    applyFixities fixs stmt = case stmt of+        Generator l p e       -> liftM2 (Generator l) (fix p) (fix e)+        Qualifier l e         -> liftM (Qualifier l) $ fix e+        LetStmt l bs          -> liftM (LetStmt l) $ fix bs    -- special behavior+        RecStmt l stmts       -> liftM (RecStmt l) $ mapM fix stmts+      where fix x = applyFixities fixs x++instance AppFixity Binds where+    applyFixities fixs bs = case bs of+        BDecls l decls        -> liftM (BDecls l) $ appFixDecls Nothing fixs decls  -- special behavior+        IPBinds l ips         -> liftM (IPBinds l) $ mapM fix ips+      where fix x = applyFixities fixs x+++instance AppFixity IPBind where+    applyFixities fixs (IPBind l n e) = liftM (IPBind l n) $ applyFixities fixs e++instance AppFixity FieldUpdate where+    applyFixities fixs (FieldUpdate l n e) = liftM (FieldUpdate l n) $ applyFixities fixs e+    applyFixities _ fup = return fup++instance AppFixity Alt where+    applyFixities fixs (Alt l p galts bs) = liftM3 (Alt l) (fix p) (fix galts) (mapM fix bs)+      where fix x = applyFixities fixs x++instance AppFixity GuardedAlts where+    applyFixities fixs galts = case galts of+        UnGuardedAlt l e      -> liftM (UnGuardedAlt l) $ fix e+        GuardedAlts  l galts  -> liftM (GuardedAlts l) $ mapM fix galts+      where fix x = applyFixities fixs x++instance AppFixity GuardedAlt where+    applyFixities fixs (GuardedAlt l stmts e) = liftM2 (GuardedAlt l) (mapM fix stmts) (fix e)+      where fix x = applyFixities fixs x++instance AppFixity QualStmt where+    applyFixities fixs qstmt = case qstmt of+        QualStmt     l s      -> liftM (QualStmt l) $ fix s+        ThenTrans    l e      -> liftM (ThenTrans l) $ fix e+        ThenBy       l e1 e2  -> liftM2 (ThenBy l) (fix e1) (fix e2)+        GroupBy      l e      -> liftM (GroupBy l) (fix e)+        GroupUsing   l e      -> liftM (GroupUsing l) (fix e)+        GroupByUsing l e1 e2  -> liftM2 (GroupByUsing l) (fix e1) (fix e2)+      where fix x = applyFixities fixs x++instance AppFixity Bracket where+    applyFixities fixs br = case br of+        ExpBracket l e    -> liftM (ExpBracket l) $ fix e+        PatBracket l p    -> liftM (PatBracket l) $ fix p+        DeclBracket l ds  -> liftM (DeclBracket l) $ mapM fix ds+        _                 -> return br+      where fix x = applyFixities fixs x++instance AppFixity Splice where+    applyFixities fixs (ParenSplice l e) = liftM (ParenSplice l) $ applyFixities fixs e+    applyFixities _ s = return s++instance AppFixity XAttr where+    applyFixities fixs (XAttr l n e) = liftM (XAttr l n) $ applyFixities fixs e+++-- the boring boilerplate stuff for expressions too+-- Recursively fixes the "leaves" of the infix chains,+-- without yet touching the chain itself. We assume all chains are+-- left-associate to begin with.+leafFix fixs e = case e of+    InfixApp l e1 op e2       -> liftM2 (flip (InfixApp l) op) (leafFix fixs e1) (fix e2)+    App l e1 e2               -> liftM2 (App l) (fix e1) (fix e2)+    NegApp l e                -> liftM (NegApp l) $ fix e+    Lambda l pats e           -> liftM2 (Lambda l) (mapM fix pats) $ fix e+    Let l bs e                -> liftM2 (Let l) (fix bs) $ fix e+    If l e a b                -> liftM3 (If l) (fix e) (fix a) (fix b)+    Case l e alts             -> liftM2 (Case l) (fix e) $ mapM fix alts+    Do l stmts                -> liftM (Do l) $ mapM fix stmts+    MDo l stmts               -> liftM (MDo l) $ mapM fix stmts+    Tuple l bx exps           -> liftM (Tuple l bx) $ mapM fix exps+    List l exps               -> liftM (List l) $ mapM fix  exps+    Paren l e                 -> liftM (Paren l) $ fix e+    LeftSection l e op        -> liftM (flip (LeftSection l) op) (fix e)+    RightSection l op e       -> liftM (RightSection l op) $ fix e+    RecConstr l n fups        -> liftM (RecConstr l n) $ mapM fix fups+    RecUpdate l e fups        -> liftM2 (RecUpdate l) (fix e) $ mapM fix fups+    EnumFrom l e              -> liftM (EnumFrom l) $ fix e+    EnumFromTo l e1 e2        -> liftM2 (EnumFromTo l) (fix e1) (fix e2)+    EnumFromThen l e1 e2      -> liftM2 (EnumFromThen l) (fix e1) (fix e2)+    EnumFromThenTo l e1 e2 e3 -> liftM3 (EnumFromThenTo l) (fix e1) (fix e2) (fix e3)+    ListComp l e quals        -> liftM2 (ListComp l) (fix e) $ mapM fix quals+    ParComp  l e qualss       -> liftM2 (ParComp l) (fix e) $ mapM (mapM fix) qualss+    ExpTypeSig l e t          -> liftM (flip (ExpTypeSig l) t) (fix e)+    BracketExp l b            -> liftM (BracketExp l) $ fix b+    SpliceExp l s             -> liftM (SpliceExp l) $ fix s+    XTag l n ats mexp cs      -> liftM3 (XTag l n) (mapM fix ats) (mapM fix mexp) (mapM fix cs)+    XETag l n ats mexp        -> liftM2 (XETag l n) (mapM fix ats) (mapM fix mexp)+    XExpTag l e               -> liftM (XExpTag l) $ fix e+    XChildTag l cs            -> liftM (XChildTag l) $ mapM fix cs+    Proc l p e                -> liftM2 (Proc l) (fix p) (fix e)+    LeftArrApp l e1 e2        -> liftM2 (LeftArrApp l) (fix e1) (fix e2)+    RightArrApp l e1 e2       -> liftM2 (RightArrApp l) (fix e1) (fix e2)+    LeftArrHighApp l e1 e2    -> liftM2 (LeftArrHighApp l) (fix e1) (fix e2)+    RightArrHighApp l e1 e2   -> liftM2 (RightArrHighApp l) (fix e1) (fix e2)+    CorePragma l s e          -> liftM (CorePragma l s) (fix e)+    SCCPragma l s e           -> liftM (SCCPragma l s) (fix e)+    GenPragma l s ab cd e     -> liftM (GenPragma l s ab cd) (fix e)++    _                         -> return e+  where+    fix x = applyFixities fixs x++leafFixP fixs p = case p of+        PInfixApp l p1 op p2    -> liftM2 (flip (PInfixApp l) op) (leafFixP fixs p1) (fix p2)+        PNeg l p                -> liftM (PNeg l) $ fix p+        PApp l n ps             -> liftM (PApp l n) $ mapM fix ps+        PTuple l bx ps          -> liftM (PTuple l bx) $ mapM fix ps+        PList l ps              -> liftM (PList l) $ mapM fix ps+        PParen l p              -> liftM (PParen l) $ fix p+        PRec l n pfs            -> liftM (PRec l n) $ mapM fix pfs+        PAsPat l n p            -> liftM (PAsPat l n) $ fix p+        PIrrPat l p             -> liftM (PIrrPat l) $ fix p+        PatTypeSig l p t        -> liftM (flip (PatTypeSig l) t) (fix p)+        PViewPat l e p          -> liftM2 (PViewPat l) (fix e) (fix p)+        PRPat l rps             -> liftM (PRPat l) $ mapM fix rps+        PXTag l n ats mp ps     -> liftM3 (PXTag l n) (mapM fix ats) (mapM fix mp) (mapM fix ps)+        PXETag l n ats mp       -> liftM2 (PXETag l n) (mapM fix ats) (mapM fix mp)+        PXPatTag l p            -> liftM (PXPatTag l) $ fix p+        PXRPats l rps           -> liftM (PXRPats l) $ mapM fix rps+        PBangPat l p            -> liftM (PBangPat l) $ fix p+        _                       -> return p+      where fix x = applyFixities fixs x
src/Language/Haskell/Exts/Annotated/Simplify.hs view
@@ -1,524 +1,526 @@------------------------------------------------------------------------------
--- |
--- Module      :  Language.Haskell.Exts.Annotated.Simplify
--- Copyright   :  (c) Niklas Broberg 2009
--- License     :  BSD-style (see the file LICENSE.txt)
---
--- Maintainer  :  Niklas Broberg, d00nibro@chalmers.se
--- Stability   :  experimental
--- Portability :  portable
---
--- This module contains code for translating from the annotated
--- complex AST in Language.Haskell.Exts.Annotated.Syntax
--- to the simpler, sparsely annotated AST in Language.Haskell.Exts.Syntax.
--- 
--- A function @sXYZ@ translates an annotated AST node of type @XYZ l@ into
--- a simple AST node of type @XYZ@. I would have prefered to use a MPTC
--- with an fd/type family to get a single exported function name, but
--- I wish to stay Haskell 2010 compliant. Let's hope for Haskell 2011.
--- 
------------------------------------------------------------------------------
-module Language.Haskell.Exts.Annotated.Simplify where
-
-import Language.Haskell.Exts.Annotated.Syntax
-import qualified Language.Haskell.Exts.Syntax as S
-
-import Language.Haskell.Exts.SrcLoc
-
--- | Translate an annotated AST node representing a Haskell module, into
---   a simpler version that retains (almost) only abstract information.
---   In particular, XML and hybrid XML pages enabled by the XmlSyntax extension
---   are translated into standard Haskell modules with a @page@ function.
-sModule :: SrcInfo loc => Module loc -> S.Module
-sModule md = case md of
-    Module l mmh oss ids ds ->
-        let (mn, mwt, mes) = sModuleHead mmh
-         in S.Module (getPointLoc l) mn (map sModulePragma oss) mwt mes (map sImportDecl ids) (map sDecl ds)
-    XmlPage l mn oss xn attrs mat es   ->
-        let loc = getPointLoc l
-         in S.Module loc (sModuleName mn) (map sModulePragma oss)
-                      Nothing
-                      (Just [S.EVar $ S.UnQual $ S.Ident "page"])
-                        []
-                        [pageFun loc $ S.XTag loc (sXName xn) (map sXAttr attrs) (fmap sExp mat) (map sExp es)]
-    XmlHybrid l mmh oss ids ds xn attrs mat es  ->
-        let loc1 = getPointLoc l
-            loc2 = getPointLoc (ann xn)
-            (mn, mwt, mes) = sModuleHead mmh
-         in S.Module loc1 mn (map sModulePragma oss) mwt mes (map sImportDecl ids)
-                (map sDecl ds ++ [pageFun loc2 $ S.XTag loc2 (sXName xn) (map sXAttr attrs) (fmap sExp mat) (map sExp es)])
-  where pageFun :: SrcLoc -> S.Exp -> S.Decl
-        pageFun loc e = S.PatBind loc namePat Nothing rhs (S.BDecls [])
-            where namePat = S.PVar $ S.Ident "page"
-                  rhs = S.UnGuardedRhs e
-
-
--- | Translate an annotated AST node representing a Haskell declaration
---   into a simpler version. Note that in the simpler version, all declaration
---   nodes are still annotated by 'SrcLoc's.
-sDecl :: SrcInfo loc => Decl loc -> S.Decl
-sDecl decl = case decl of
-     TypeDecl     l dh t        ->
-        let (n, tvs) = sDeclHead dh
-         in S.TypeDecl (getPointLoc l) n tvs (sType t)
-     TypeFamDecl  l dh mk       ->
-        let (n, tvs) = sDeclHead dh
-         in S.TypeFamDecl (getPointLoc l) n tvs (fmap sKind mk)
-     DataDecl     l dn mctxt dh constrs mder    ->
-        let (n, tvs) = sDeclHead dh
-         in S.DataDecl (getPointLoc l) (sDataOrNew dn) (maybe [] sContext mctxt) n tvs (map sQualConDecl constrs) (maybe [] sDeriving mder)
-     GDataDecl    l dn mctxt dh mk gds mder     ->
-        let (n, tvs) = sDeclHead dh
-         in S.GDataDecl (getPointLoc l) (sDataOrNew dn) (maybe [] sContext mctxt) n tvs (fmap sKind mk) (map sGadtDecl gds) (maybe [] sDeriving mder)
-     DataFamDecl  l mctxt dh mk ->
-        let (n, tvs) = sDeclHead dh
-         in S.DataFamDecl (getPointLoc l) (maybe [] sContext mctxt) n tvs (fmap sKind mk)
-     TypeInsDecl  l t1 t2       -> S.TypeInsDecl (getPointLoc l) (sType t1) (sType t2)
-     DataInsDecl  l dn t constrs mder           ->
-        S.DataInsDecl (getPointLoc l) (sDataOrNew dn) (sType t) (map sQualConDecl constrs) (maybe [] sDeriving mder)
-     GDataInsDecl l dn t mk gds mder            ->
-        S.GDataInsDecl (getPointLoc l) (sDataOrNew dn) (sType t) (fmap sKind mk) (map sGadtDecl gds) (maybe [] sDeriving mder)
-     ClassDecl    l mctxt dh fds mcds           ->
-        let (n, tvs) = sDeclHead dh
-         in S.ClassDecl (getPointLoc l) (maybe [] sContext mctxt) n tvs (map sFunDep fds) (maybe [] (map sClassDecl) mcds)
-     InstDecl     l mctxt ih mids               ->
-        let (qn, ts) = sInstHead ih
-         in S.InstDecl (getPointLoc l) (maybe [] sContext mctxt) qn ts (maybe [] (map sInstDecl) mids)
-     DerivDecl    l mctxt ih    ->
-        let (qn, ts) = sInstHead ih
-         in S.DerivDecl (getPointLoc l) (maybe [] sContext mctxt) qn ts
-     InfixDecl    l ass prec ops    -> S.InfixDecl (getPointLoc l) (sAssoc ass) (maybe 9 id prec) (map sOp ops)
-     DefaultDecl  l ts          -> S.DefaultDecl (getPointLoc l) (map sType ts)
-     SpliceDecl   l sp          -> S.SpliceDecl (getPointLoc l) (sExp sp)
-     TypeSig      l ns t        -> S.TypeSig (getPointLoc l) (map sName ns) (sType t)
-     FunBind      _ ms          -> S.FunBind (map sMatch ms)
-     PatBind      l p mt rhs mbs    ->
-        S.PatBind (getPointLoc l) (sPat p) (fmap sType mt) (sRhs rhs) (maybe (S.BDecls []) sBinds mbs)
-     ForImp       l cc msaf mstr n t    ->
-        S.ForImp (getPointLoc l) (sCallConv cc) (maybe (S.PlaySafe False) sSafety msaf) (maybe "" id mstr) (sName n) (sType t)
-     ForExp       l cc      mstr n t    ->
-        S.ForExp (getPointLoc l) (sCallConv cc) (maybe "" id mstr) (sName n) (sType t)
-     RulePragmaDecl   l rs      -> S.RulePragmaDecl (getPointLoc l) (map sRule rs)
-     DeprPragmaDecl   l nsstrs  -> S.DeprPragmaDecl (getPointLoc l) (map (\(ns, str) -> (map sName ns, str)) nsstrs)
-     WarnPragmaDecl   l nsstrs  -> S.WarnPragmaDecl (getPointLoc l) (map (\(ns, str) -> (map sName ns, str)) nsstrs)
-     InlineSig        l b mact qn   -> S.InlineSig (getPointLoc l) b (maybe S.AlwaysActive sActivation mact) (sQName qn)
-     InlineConlikeSig l   mact qn   -> S.InlineConlikeSig (getPointLoc l) (maybe S.AlwaysActive sActivation mact) (sQName qn)
-     SpecSig          l qn ts   -> S.SpecSig (getPointLoc l) (sQName qn) (map sType ts)
-     SpecInlineSig    l b mact qn ts    ->
-        S.SpecInlineSig (getPointLoc l) b (maybe S.AlwaysActive sActivation mact) (sQName qn) (map sType ts)
-     InstSig          l mctxt ih    ->
-        let (qn, ts) = sInstHead ih
-         in S.InstSig (getPointLoc l) (maybe [] sContext mctxt) qn ts
-     AnnPragma        l ann         ->
-        S.AnnPragma (getPointLoc l) (sAnnotation ann)
-
-sAnnotation :: SrcInfo loc => Annotation loc -> S.Annotation
-sAnnotation ann = case ann of
-    Ann       _ n e   -> S.Ann     (sName n) (sExp e)
-    TypeAnn   _ n e   -> S.TypeAnn (sName n) (sExp e)
-    ModuleAnn _   e   -> S.ModuleAnn         (sExp e)
-
-sModuleName :: ModuleName l -> S.ModuleName
-sModuleName (ModuleName _ str)  = S.ModuleName str
-
-sSpecialCon :: SpecialCon l -> S.SpecialCon
-sSpecialCon sc = case sc of
-    UnitCon _           -> S.UnitCon
-    ListCon _           -> S.ListCon
-    FunCon  _           -> S.FunCon
-    TupleCon _ b k      -> S.TupleCon b k
-    Cons _              -> S.Cons
-    UnboxedSingleCon _  -> S.UnboxedSingleCon
-
-sQName :: QName l -> S.QName
-sQName qn = case qn of
-    Qual    _ mn n  -> S.Qual (sModuleName mn) (sName n)
-    UnQual  _    n  -> S.UnQual (sName n)
-    Special _ sc    -> S.Special (sSpecialCon sc)
-
-sName :: Name l -> S.Name
-sName (Ident _ str) = S.Ident str
-sName (Symbol _ str) = S.Symbol str
-
-sIPName :: IPName l -> S.IPName
-sIPName (IPDup _ str) = S.IPDup str
-sIPName (IPLin _ str) = S.IPLin str
-
-sQOp :: QOp l -> S.QOp
-sQOp (QVarOp _ qn) = S.QVarOp (sQName qn)
-sQOp (QConOp _ qn) = S.QConOp (sQName qn)
-
-sOp :: Op l -> S.Op
-sOp (VarOp _ n) = S.VarOp (sName n)
-sOp (ConOp _ n) = S.ConOp (sName n)
-
-sCName :: CName l -> S.CName
-sCName (VarName _ n) = S.VarName (sName n)
-sCName (ConName _ n) = S.ConName (sName n)
-
-sModuleHead :: Maybe (ModuleHead l) -> (S.ModuleName, Maybe (S.WarningText), Maybe [S.ExportSpec])
-sModuleHead mmh = case mmh of
-    Nothing -> (S.main_mod, Nothing, Just [S.EVar (S.UnQual S.main_name)])
-    Just (ModuleHead _ mn mwt mel) -> (sModuleName mn, fmap sWarningText mwt, fmap sExportSpecList mel)
-
-sExportSpecList :: ExportSpecList l -> [S.ExportSpec]
-sExportSpecList (ExportSpecList _ ess) = map sExportSpec ess
-
-sExportSpec :: ExportSpec l -> S.ExportSpec
-sExportSpec es = case es of
-    EVar _ qn           -> S.EVar (sQName qn)
-    EAbs _ qn           -> S.EAbs (sQName qn)
-    EThingAll _ qn      -> S.EThingAll (sQName qn)
-    EThingWith _ qn cns -> S.EThingWith (sQName qn) (map sCName cns)
-    EModuleContents _ mn    -> S.EModuleContents (sModuleName mn)
-
-sImportDecl :: SrcInfo loc => ImportDecl loc -> S.ImportDecl
-sImportDecl (ImportDecl l mn qu src mpkg as misl) =
-    S.ImportDecl (getPointLoc l) (sModuleName mn) qu src mpkg (fmap sModuleName as) (fmap sImportSpecList misl)
-
-sImportSpecList :: ImportSpecList l -> (Bool, [S.ImportSpec])
-sImportSpecList (ImportSpecList _ b iss) = (b, map sImportSpec iss)
-
-sImportSpec :: ImportSpec l -> S.ImportSpec
-sImportSpec is = case is of
-    IVar _ n            -> S.IVar (sName n)
-    IAbs _ n            -> S.IAbs (sName n)
-    IThingAll _ n       -> S.IThingAll (sName n)
-    IThingWith _ n cns  -> S.IThingWith (sName n) (map sCName cns)
-
-sAssoc :: Assoc l -> S.Assoc
-sAssoc a = case a of
-    AssocNone  _ -> S.AssocNone
-    AssocLeft  _ -> S.AssocLeft
-    AssocRight _ -> S.AssocRight
-
-sDeclHead :: DeclHead l -> (S.Name, [S.TyVarBind])
-sDeclHead dh = case dh of
-    DHead _ n tvs       -> (sName n, map sTyVarBind tvs)
-    DHInfix _ tva n tvb -> (sName n, map sTyVarBind [tva,tvb])
-    DHParen _ dh        -> sDeclHead dh
-
-sInstHead :: InstHead l -> (S.QName, [S.Type])
-sInstHead ih = case ih of
-    IHead _ qn ts      -> (sQName qn, map sType ts)
-    IHInfix _ ta qn tb -> (sQName qn, map sType [ta,tb])
-    IHParen _ ih       -> sInstHead ih
-
-sDataOrNew :: DataOrNew l -> S.DataOrNew
-sDataOrNew (DataType _) = S.DataType
-sDataOrNew (NewType _) = S.NewType
-
-sDeriving :: (Deriving l) -> [(S.QName, [S.Type])]
-sDeriving (Deriving _ ihs) = map sInstHead ihs
-
-sBinds :: SrcInfo loc => Binds loc -> S.Binds
-sBinds bs = case bs of
-    BDecls  _ decls     -> S.BDecls (map sDecl decls)
-    IPBinds _ ipbds     -> S.IPBinds (map sIPBind ipbds)
-
-sIPBind :: SrcInfo loc => IPBind loc -> S.IPBind
-sIPBind (IPBind l ipn e) = S.IPBind (getPointLoc l) (sIPName ipn) (sExp e)
-
-sMatch :: SrcInfo loc => Match loc -> S.Match
-sMatch (Match l n ps rhs mwhere) =
-    S.Match (getPointLoc l) (sName n) (map sPat ps) Nothing (sRhs rhs) (maybe (S.BDecls []) sBinds mwhere)
-sMatch (InfixMatch l pa n pbs rhs mwhere) =
-    S.Match (getPointLoc l) (sName n) (map sPat (pa:pbs)) Nothing (sRhs rhs) (maybe (S.BDecls []) sBinds mwhere)
-
-sQualConDecl :: SrcInfo loc => QualConDecl loc -> S.QualConDecl
-sQualConDecl (QualConDecl l mtvs mctxt cd) =
-    S.QualConDecl (getPointLoc l) (maybe [] (map sTyVarBind) mtvs) (maybe [] sContext mctxt) (sConDecl cd)
-
-sConDecl :: ConDecl l -> S.ConDecl
-sConDecl cd = case cd of
-    ConDecl _ n bts     -> S.ConDecl (sName n) (map sBangType bts)
-    InfixConDecl _ bta n btb -> S.InfixConDecl (sBangType bta) (sName n) (sBangType btb)
-    RecDecl _ n fds -> S.RecDecl (sName n) (map sFieldDecl fds)
-
-sFieldDecl :: FieldDecl l -> ([S.Name], S.BangType)
-sFieldDecl (FieldDecl _ ns bt) = (map sName ns, sBangType bt)
-
-sGadtDecl :: SrcInfo loc => GadtDecl loc -> S.GadtDecl
-sGadtDecl (GadtDecl l n t) = S.GadtDecl (getPointLoc l) (sName n) (sType t)
-
-sClassDecl :: SrcInfo loc => ClassDecl loc -> S.ClassDecl
-sClassDecl cd = case cd of
-    ClsDecl _ d  -> S.ClsDecl (sDecl d)
-    ClsDataFam l mctxt dh mk    ->
-        let (n, tvs) = sDeclHead dh
-         in S.ClsDataFam (getPointLoc l) (maybe [] sContext mctxt) n tvs (fmap sKind mk)
-    ClsTyFam l dh mk    ->
-        let (n, tvs) = sDeclHead dh
-         in S.ClsTyFam (getPointLoc l) n tvs (fmap sKind mk)
-    ClsTyDef l t1 t2    ->
-        S.ClsTyDef (getPointLoc l) (sType t1) (sType t2)
-
-sInstDecl :: SrcInfo loc => InstDecl loc -> S.InstDecl
-sInstDecl id = case id of
-    InsDecl   _ d   -> S.InsDecl (sDecl d)
-    InsType   l t1 t2   -> S.InsType (getPointLoc l) (sType t1) (sType t2)
-    InsData   l dn t constrs mder   ->
-        S.InsData (getPointLoc l) (sDataOrNew dn) (sType t) (map sQualConDecl constrs) (maybe [] sDeriving mder)
-    InsGData  l dn t mk gds mder    ->
-        S.InsGData (getPointLoc l) (sDataOrNew dn) (sType t) (fmap sKind mk) (map sGadtDecl gds) (maybe [] sDeriving mder)
---    InsInline l b mact qn   -> S.InsInline (getPointLoc l) b (maybe S.AlwaysActive sActivation mact) (sQName qn)
-
-sBangType :: BangType l -> S.BangType
-sBangType bt = case bt of
-    BangedTy   _ t  -> S.BangedTy (sType t)
-    UnBangedTy _ t  -> S.UnBangedTy (sType t)
-    UnpackedTy _ t  -> S.UnpackedTy (sType t)
-
-sRhs :: SrcInfo loc => Rhs loc -> S.Rhs
-sRhs (UnGuardedRhs _ e) = S.UnGuardedRhs (sExp e)
-sRhs (GuardedRhss _ grhss) = S.GuardedRhss (map sGuardedRhs grhss)
-
-sGuardedRhs :: SrcInfo loc => GuardedRhs loc -> S.GuardedRhs
-sGuardedRhs (GuardedRhs l ss e) = S.GuardedRhs (getPointLoc l) (map sStmt ss) (sExp e)
-
-sType :: Type l -> S.Type
-sType t = case t of
-    TyForall _ mtvs mctxt t     -> S.TyForall (fmap (map sTyVarBind) mtvs) (maybe [] sContext mctxt) (sType t)
-    TyFun _ t1 t2               -> S.TyFun (sType t1) (sType t2)
-    TyTuple _ bx ts             -> S.TyTuple bx (map sType ts)
-    TyList _ t                  -> S.TyList (sType t)
-    TyApp _ t1 t2               -> S.TyApp (sType t1) (sType t2)
-    TyVar _ n                   -> S.TyVar (sName n)
-    TyCon _ qn                  -> S.TyCon (sQName qn)
-    TyParen _ t                 -> S.TyParen (sType t)
-    TyInfix _ ta qn tb          -> S.TyInfix (sType ta) (sQName qn) (sType tb)
-    TyKind _ t k                -> S.TyKind (sType t) (sKind k)
-
-sTyVarBind :: TyVarBind l -> S.TyVarBind
-sTyVarBind (KindedVar _ n k) = S.KindedVar (sName n) (sKind k)
-sTyVarBind (UnkindedVar _ n) = S.UnkindedVar (sName n)
-
-sKind :: Kind l -> S.Kind
-sKind k = case k of
-    KindStar  _     -> S.KindStar
-    KindBang  _     -> S.KindBang
-    KindFn _ k1 k2  -> S.KindFn (sKind k1) (sKind k2)
-    KindParen _ k   -> S.KindParen (sKind k)
-    KindVar _ n     -> S.KindVar (sName n)
-
-sFunDep :: FunDep l -> S.FunDep
-sFunDep (FunDep _ as bs) = S.FunDep (map sName as) (map sName bs)
-
-sContext :: Context l -> S.Context
-sContext ctxt = case ctxt of
-    CxSingle _ asst     -> [sAsst asst]
-    CxTuple  _ assts    -> map sAsst assts
-    CxParen  _ ct       -> sContext ct
-    CxEmpty  _          -> []
-
-sAsst :: Asst l -> S.Asst
-sAsst asst = case asst of
-    ClassA _ qn ts      -> S.ClassA (sQName qn) (map sType ts)
-    InfixA _ ta qn tb   -> S.InfixA (sType ta) (sQName qn) (sType tb)
-    IParam _ ipn t      -> S.IParam (sIPName ipn) (sType t)
-    EqualP _ t1 t2      -> S.EqualP (sType t1) (sType t2)
-
-sLiteral :: Literal l -> S.Literal
-sLiteral lit = case lit of
-    Char       _ c _ -> S.Char c
-    String     _ s _ -> S.String s
-    Int        _ i _ -> S.Int i
-    Frac       _ r _ -> S.Frac r
-    PrimInt    _ i _ -> S.PrimInt i
-    PrimWord   _ i _ -> S.PrimWord i
-    PrimFloat  _ r _ -> S.PrimFloat r
-    PrimDouble _ r _ -> S.PrimDouble r
-    PrimChar   _ c _ -> S.PrimChar c
-    PrimString _ s _ -> S.PrimString s
-
-sExp :: SrcInfo loc => Exp loc -> S.Exp
-sExp e = case e of
-    Var _ qn            -> S.Var (sQName qn)
-    IPVar _ ipn         -> S.IPVar (sIPName ipn)
-    Con _ qn            -> S.Con (sQName qn)
-    Lit _ lit           -> S.Lit (sLiteral lit)
-    InfixApp _ e1 op e2 -> S.InfixApp (sExp e1) (sQOp op) (sExp e2)
-    App _ e1 e2         -> S.App (sExp e1) (sExp e2)
-    NegApp _ e          -> S.NegApp (sExp e)
-    Lambda l ps e       -> S.Lambda (getPointLoc l) (map sPat ps) (sExp e)
-    Let _ bs e          -> S.Let (sBinds bs) (sExp e)
-    If _ e1 e2 e3       -> S.If (sExp e1) (sExp e2) (sExp e3)
-    Case _ e alts       -> S.Case (sExp e) (map sAlt alts)
-    Do _ ss             -> S.Do (map sStmt ss)
-    MDo _ ss            -> S.MDo (map sStmt ss)
-    Tuple _ es          -> S.Tuple (map sExp es)
-    TupleSection _ mes  -> S.TupleSection (map (fmap sExp) mes)
-    List _ es           -> S.List (map sExp es)
-    Paren _ e           -> S.Paren (sExp e)
-    LeftSection _ e op  -> S.LeftSection (sExp e) (sQOp op)
-    RightSection _ op e -> S.RightSection (sQOp op) (sExp e)
-    RecConstr _ qn fups -> S.RecConstr (sQName qn) (map sFieldUpdate fups)
-    RecUpdate _ e fups  -> S.RecUpdate (sExp e) (map sFieldUpdate fups)
-    EnumFrom _ e        -> S.EnumFrom (sExp e)
-    EnumFromTo _ e1 e2  -> S.EnumFromTo (sExp e1) (sExp e2)
-    EnumFromThen _ e1 e2    -> S.EnumFromThen (sExp e1) (sExp e2)
-    EnumFromThenTo _ e1 e2 e3   -> S.EnumFromThenTo (sExp e1) (sExp e2) (sExp e3)
-    ListComp _ e qss    -> S.ListComp (sExp e) (map sQualStmt qss)
-    ParComp  _ e qsss   -> S.ParComp (sExp e) (map (map sQualStmt) qsss)
-    ExpTypeSig l e t    -> S.ExpTypeSig (getPointLoc l) (sExp e) (sType t)
-    VarQuote _ qn       -> S.VarQuote (sQName qn)
-    TypQuote _ qn       -> S.TypQuote (sQName qn)
-    BracketExp _ br     -> S.BracketExp (sBracket br)
-    SpliceExp _ sp      -> S.SpliceExp (sSplice sp)
-    QuasiQuote _ nm qt  -> S.QuasiQuote nm qt
-    XTag l xn attrs mat es  -> S.XTag  (getPointLoc l) (sXName xn) (map sXAttr attrs) (fmap sExp mat) (map sExp es)
-    XETag l xn attrs mat    -> S.XETag (getPointLoc l) (sXName xn) (map sXAttr attrs) (fmap sExp mat)
-    XPcdata _ str       -> S.XPcdata str
-    XExpTag _ e         -> S.XExpTag (sExp e)
-    XChildTag l es      -> S.XChildTag (getPointLoc l) (map sExp es)
-    CorePragma _ str e  -> S.CorePragma str (sExp e)
-    SCCPragma  _ str e  -> S.SCCPragma  str (sExp e)
-    GenPragma  _ str i12 i34 e  -> S.GenPragma str i12 i34 (sExp e)
-    Proc            l p  e  -> S.Proc (getPointLoc l) (sPat p) (sExp e)
-    LeftArrApp      _ e1 e2 -> S.LeftArrApp (sExp e1) (sExp e2)
-    RightArrApp     _ e1 e2 -> S.RightArrApp (sExp e1) (sExp e2)
-    LeftArrHighApp  _ e1 e2 -> S.LeftArrHighApp (sExp e1) (sExp e2)
-    RightArrHighApp _ e1 e2 -> S.RightArrHighApp (sExp e1) (sExp e2)
-
-
-sXName :: XName l -> S.XName
-sXName (XName _ str) = S.XName str
-sXName (XDomName _ dom str) = S.XDomName dom str
-
-sXAttr :: SrcInfo loc => XAttr loc -> S.XAttr
-sXAttr (XAttr _ xn e) = S.XAttr (sXName xn) (sExp e)
-
-sBracket:: SrcInfo loc => Bracket loc -> S.Bracket
-sBracket br = case br of
-    ExpBracket _ e  -> S.ExpBracket (sExp e)
-    PatBracket _ p  -> S.PatBracket (sPat p)
-    TypeBracket _ t -> S.TypeBracket (sType t)
-    DeclBracket _ ds -> S.DeclBracket (map sDecl ds)
-
-sSplice :: SrcInfo loc => Splice loc -> S.Splice
-sSplice (IdSplice _ str) = S.IdSplice str
-sSplice (ParenSplice _ e) = S.ParenSplice (sExp e)
-
-sSafety :: Safety l -> S.Safety
-sSafety (PlayRisky _) = S.PlayRisky
-sSafety (PlaySafe _ b) = S.PlaySafe b
-
-sCallConv :: CallConv l -> S.CallConv
-sCallConv (StdCall   _) = S.StdCall
-sCallConv (CCall     _) = S.CCall
-sCallConv (CPlusPlus _) = S.CPlusPlus
-sCallConv (DotNet    _) = S.DotNet
-sCallConv (Jvm       _) = S.Jvm
-sCallConv (Js        _ ) = S.Js
-
-sModulePragma :: SrcInfo loc => ModulePragma loc -> S.ModulePragma
-sModulePragma pr = case pr of
-    LanguagePragma   l ns   -> S.LanguagePragma (getPointLoc l) (map sName ns)
-    OptionsPragma    l mt str -> S.OptionsPragma (getPointLoc l) mt str
-    AnnModulePragma  l ann -> S.AnnModulePragma (getPointLoc l) (sAnnotation ann)
-
-sActivation :: Activation l -> S.Activation
-sActivation act = case act of
-    ActiveFrom   _ k    -> S.ActiveFrom k
-    ActiveUntil  _ k    -> S.ActiveUntil k
-
-sRule :: SrcInfo loc => Rule loc -> S.Rule
-sRule (Rule _ str mact mrvs e1 e2) =
-    S.Rule str (maybe S.AlwaysActive sActivation mact) (fmap (map sRuleVar) mrvs) (sExp e1) (sExp e2)
-
-sRuleVar :: RuleVar l -> S.RuleVar
-sRuleVar (RuleVar _ n) = S.RuleVar (sName n)
-sRuleVar (TypedRuleVar _ n t) = S.TypedRuleVar (sName n) (sType t)
-
-sWarningText :: WarningText l -> S.WarningText
-sWarningText (DeprText _ str) = S.DeprText str
-sWarningText (WarnText _ str) = S.WarnText str
-
-sPat :: SrcInfo loc => Pat loc -> S.Pat
-sPat pat = case pat of
-    PVar _ n            -> S.PVar (sName n)
-    PLit _ lit          -> S.PLit (sLiteral lit)
-    PNeg _ p            -> S.PNeg (sPat p)
-    PNPlusK _ n k       -> S.PNPlusK (sName n) k
-    PInfixApp _ pa qn pb -> S.PInfixApp (sPat pa) (sQName qn) (sPat pb)
-    PApp _ qn ps        -> S.PApp (sQName qn) (map sPat ps)
-    PTuple _ ps         -> S.PTuple (map sPat ps)
-    PList _ ps          -> S.PList (map sPat ps)
-    PParen _ p          -> S.PParen (sPat p)
-    PRec _ qn pfs       -> S.PRec (sQName qn) (map sPatField pfs)
-    PAsPat _ n p        -> S.PAsPat (sName n) (sPat p)
-    PWildCard _         -> S.PWildCard
-    PIrrPat _ p         -> S.PIrrPat (sPat p)
-    PatTypeSig l p t    -> S.PatTypeSig (getPointLoc l) (sPat p) (sType t)
-    PViewPat _ e p      -> S.PViewPat (sExp e) (sPat p)
-    PRPat _ rps         -> S.PRPat (map sRPat rps)
-    PXTag l xn attrs mat ps -> S.PXTag (getPointLoc l) (sXName xn) (map sPXAttr attrs) (fmap sPat mat) (map sPat ps)
-    PXETag l xn attrs mat   -> S.PXETag (getPointLoc l) (sXName xn) (map sPXAttr attrs) (fmap sPat mat)
-    PXPcdata _ str      -> S.PXPcdata str
-    PXPatTag _ p        -> S.PXPatTag (sPat p)
-    PXRPats  _ rps      -> S.PXRPats (map sRPat rps)
-    PExplTypeArg _ qn t -> S.PExplTypeArg (sQName qn) (sType t)
-    PQuasiQuote _ nm qt -> S.PQuasiQuote nm qt
-    PBangPat _ p        -> S.PBangPat (sPat p)
-
-sPXAttr :: SrcInfo loc => PXAttr loc -> S.PXAttr
-sPXAttr (PXAttr _ xn p) = S.PXAttr (sXName xn) (sPat p)
-
-sRPatOp :: RPatOp l -> S.RPatOp
-sRPatOp rpop = case rpop of
-    RPStar  _ -> S.RPStar
-    RPStarG _ -> S.RPStarG
-    RPPlus  _ -> S.RPPlus
-    RPPlusG _ -> S.RPPlusG
-    RPOpt   _ -> S.RPOpt
-    RPOptG  _ -> S.RPOptG
-
-sRPat :: SrcInfo loc => RPat loc -> S.RPat
-sRPat rp = case rp of
-    RPOp _ rp rop       -> S.RPOp (sRPat rp) (sRPatOp rop)
-    RPEither _ rp1 rp2  -> S.RPEither (sRPat rp1) (sRPat rp2)
-    RPSeq _ rps         -> S.RPSeq (map sRPat rps)
-    RPGuard _ p ss      -> S.RPGuard (sPat p) (map sStmt ss)
-    RPCAs _ n rp        -> S.RPCAs (sName n) (sRPat rp)
-    RPAs _ n rp         -> S.RPAs (sName n) (sRPat rp)
-    RPParen _ rp        -> S.RPParen (sRPat rp)
-    RPPat _ p           -> S.RPPat (sPat p)
-
-sPatField :: SrcInfo loc => PatField loc -> S.PatField
-sPatField pf = case pf of
-    PFieldPat _ qn p    -> S.PFieldPat (sQName qn) (sPat p)
-    PFieldPun _ n       -> S.PFieldPun (sName n)
-    PFieldWildcard _    -> S.PFieldWildcard
-
-sStmt :: SrcInfo loc => Stmt loc -> S.Stmt
-sStmt stmt = case stmt of
-    Generator l p e     -> S.Generator (getPointLoc l) (sPat p) (sExp e)
-    Qualifier _ e       -> S.Qualifier (sExp e)
-    LetStmt _ bs        -> S.LetStmt (sBinds bs)
-    RecStmt _ ss        -> S.RecStmt (map sStmt ss)
-
-sQualStmt :: SrcInfo loc => QualStmt loc -> S.QualStmt
-sQualStmt qs = case qs of
-    QualStmt     _ stmt     -> S.QualStmt (sStmt stmt)
-    ThenTrans    _ e        -> S.ThenTrans (sExp e)
-    ThenBy       _ e1 e2    -> S.ThenBy (sExp e1) (sExp e2)
-    GroupBy      _ e        -> S.GroupBy (sExp e)
-    GroupUsing   _ e        -> S.GroupUsing (sExp e)
-    GroupByUsing _ e1 e2    -> S.GroupByUsing (sExp e1) (sExp e2)
-
-sFieldUpdate :: SrcInfo loc => FieldUpdate loc -> S.FieldUpdate
-sFieldUpdate fu = case fu of
-    FieldUpdate _ qn e      -> S.FieldUpdate (sQName qn) (sExp e)
-    FieldPun _ n            -> S.FieldPun (sName n)
-    FieldWildcard _         -> S.FieldWildcard
-
-sAlt :: SrcInfo loc => Alt loc -> S.Alt
-sAlt (Alt l p galts mbs) = S.Alt (getPointLoc l) (sPat p) (sGuardedAlts galts) (maybe (S.BDecls []) sBinds mbs)
-
-sGuardedAlts :: SrcInfo loc => GuardedAlts loc -> S.GuardedAlts
-sGuardedAlts galts = case galts of
-    UnGuardedAlt _ e    -> S.UnGuardedAlt (sExp e)
-    GuardedAlts  _ gs   -> S.GuardedAlts (map sGuardedAlt gs)
-
-sGuardedAlt :: SrcInfo loc => GuardedAlt loc -> S.GuardedAlt
-sGuardedAlt (GuardedAlt l ss e) = S.GuardedAlt (getPointLoc l) (map sStmt ss) (sExp e)
+-----------------------------------------------------------------------------+-- |+-- Module      :  Language.Haskell.Exts.Annotated.Simplify+-- Copyright   :  (c) Niklas Broberg 2009+-- License     :  BSD-style (see the file LICENSE.txt)+--+-- Maintainer  :  Niklas Broberg, d00nibro@chalmers.se+-- Stability   :  experimental+-- Portability :  portable+--+-- This module contains code for translating from the annotated+-- complex AST in Language.Haskell.Exts.Annotated.Syntax+-- to the simpler, sparsely annotated AST in Language.Haskell.Exts.Syntax.+--+-- A function @sXYZ@ translates an annotated AST node of type @XYZ l@ into+-- a simple AST node of type @XYZ@. I would have prefered to use a MPTC+-- with an fd/type family to get a single exported function name, but+-- I wish to stay Haskell 2010 compliant. Let's hope for Haskell 2011.+--+-----------------------------------------------------------------------------+module Language.Haskell.Exts.Annotated.Simplify where++import Language.Haskell.Exts.Annotated.Syntax+import qualified Language.Haskell.Exts.Syntax as S++import Language.Haskell.Exts.SrcLoc++-- | Translate an annotated AST node representing a Haskell module, into+--   a simpler version that retains (almost) only abstract information.+--   In particular, XML and hybrid XML pages enabled by the XmlSyntax extension+--   are translated into standard Haskell modules with a @page@ function.+sModule :: SrcInfo loc => Module loc -> S.Module+sModule md = case md of+    Module l mmh oss ids ds ->+        let (mn, mwt, mes) = sModuleHead mmh+         in S.Module (getPointLoc l) mn (map sModulePragma oss) mwt mes (map sImportDecl ids) (map sDecl ds)+    XmlPage l mn oss xn attrs mat es   ->+        let loc = getPointLoc l+         in S.Module loc (sModuleName mn) (map sModulePragma oss)+                      Nothing+                      (Just [S.EVar $ S.UnQual $ S.Ident "page"])+                        []+                        [pageFun loc $ S.XTag loc (sXName xn) (map sXAttr attrs) (fmap sExp mat) (map sExp es)]+    XmlHybrid l mmh oss ids ds xn attrs mat es  ->+        let loc1 = getPointLoc l+            loc2 = getPointLoc (ann xn)+            (mn, mwt, mes) = sModuleHead mmh+         in S.Module loc1 mn (map sModulePragma oss) mwt mes (map sImportDecl ids)+                (map sDecl ds ++ [pageFun loc2 $ S.XTag loc2 (sXName xn) (map sXAttr attrs) (fmap sExp mat) (map sExp es)])+  where pageFun :: SrcLoc -> S.Exp -> S.Decl+        pageFun loc e = S.PatBind loc namePat Nothing rhs (S.BDecls [])+            where namePat = S.PVar $ S.Ident "page"+                  rhs = S.UnGuardedRhs e+++-- | Translate an annotated AST node representing a Haskell declaration+--   into a simpler version. Note that in the simpler version, all declaration+--   nodes are still annotated by 'SrcLoc's.+sDecl :: SrcInfo loc => Decl loc -> S.Decl+sDecl decl = case decl of+     TypeDecl     l dh t        ->+        let (n, tvs) = sDeclHead dh+         in S.TypeDecl (getPointLoc l) n tvs (sType t)+     TypeFamDecl  l dh mk       ->+        let (n, tvs) = sDeclHead dh+         in S.TypeFamDecl (getPointLoc l) n tvs (fmap sKind mk)+     DataDecl     l dn mctxt dh constrs mder    ->+        let (n, tvs) = sDeclHead dh+         in S.DataDecl (getPointLoc l) (sDataOrNew dn) (maybe [] sContext mctxt) n tvs (map sQualConDecl constrs) (maybe [] sDeriving mder)+     GDataDecl    l dn mctxt dh mk gds mder     ->+        let (n, tvs) = sDeclHead dh+         in S.GDataDecl (getPointLoc l) (sDataOrNew dn) (maybe [] sContext mctxt) n tvs (fmap sKind mk) (map sGadtDecl gds) (maybe [] sDeriving mder)+     DataFamDecl  l mctxt dh mk ->+        let (n, tvs) = sDeclHead dh+         in S.DataFamDecl (getPointLoc l) (maybe [] sContext mctxt) n tvs (fmap sKind mk)+     TypeInsDecl  l t1 t2       -> S.TypeInsDecl (getPointLoc l) (sType t1) (sType t2)+     DataInsDecl  l dn t constrs mder           ->+        S.DataInsDecl (getPointLoc l) (sDataOrNew dn) (sType t) (map sQualConDecl constrs) (maybe [] sDeriving mder)+     GDataInsDecl l dn t mk gds mder            ->+        S.GDataInsDecl (getPointLoc l) (sDataOrNew dn) (sType t) (fmap sKind mk) (map sGadtDecl gds) (maybe [] sDeriving mder)+     ClassDecl    l mctxt dh fds mcds           ->+        let (n, tvs) = sDeclHead dh+         in S.ClassDecl (getPointLoc l) (maybe [] sContext mctxt) n tvs (map sFunDep fds) (maybe [] (map sClassDecl) mcds)+     InstDecl     l mctxt ih mids               ->+        let (qn, ts) = sInstHead ih+         in S.InstDecl (getPointLoc l) (maybe [] sContext mctxt) qn ts (maybe [] (map sInstDecl) mids)+     DerivDecl    l mctxt ih    ->+        let (qn, ts) = sInstHead ih+         in S.DerivDecl (getPointLoc l) (maybe [] sContext mctxt) qn ts+     InfixDecl    l ass prec ops    -> S.InfixDecl (getPointLoc l) (sAssoc ass) (maybe 9 id prec) (map sOp ops)+     DefaultDecl  l ts          -> S.DefaultDecl (getPointLoc l) (map sType ts)+     SpliceDecl   l sp          -> S.SpliceDecl (getPointLoc l) (sExp sp)+     TypeSig      l ns t        -> S.TypeSig (getPointLoc l) (map sName ns) (sType t)+     FunBind      _ ms          -> S.FunBind (map sMatch ms)+     PatBind      l p mt rhs mbs    ->+        S.PatBind (getPointLoc l) (sPat p) (fmap sType mt) (sRhs rhs) (maybe (S.BDecls []) sBinds mbs)+     ForImp       l cc msaf mstr n t    ->+        S.ForImp (getPointLoc l) (sCallConv cc) (maybe (S.PlaySafe False) sSafety msaf) (maybe "" id mstr) (sName n) (sType t)+     ForExp       l cc      mstr n t    ->+        S.ForExp (getPointLoc l) (sCallConv cc) (maybe "" id mstr) (sName n) (sType t)+     RulePragmaDecl   l rs      -> S.RulePragmaDecl (getPointLoc l) (map sRule rs)+     DeprPragmaDecl   l nsstrs  -> S.DeprPragmaDecl (getPointLoc l) (map (\(ns, str) -> (map sName ns, str)) nsstrs)+     WarnPragmaDecl   l nsstrs  -> S.WarnPragmaDecl (getPointLoc l) (map (\(ns, str) -> (map sName ns, str)) nsstrs)+     InlineSig        l b mact qn   -> S.InlineSig (getPointLoc l) b (maybe S.AlwaysActive sActivation mact) (sQName qn)+     InlineConlikeSig l   mact qn   -> S.InlineConlikeSig (getPointLoc l) (maybe S.AlwaysActive sActivation mact) (sQName qn)+     SpecSig          l   mact qn ts   -> S.SpecSig (getPointLoc l) (maybe S.AlwaysActive sActivation mact) (sQName qn) (map sType ts)+     SpecInlineSig    l b mact qn ts    ->+        S.SpecInlineSig (getPointLoc l) b (maybe S.AlwaysActive sActivation mact) (sQName qn) (map sType ts)+     InstSig          l mctxt ih    ->+        let (qn, ts) = sInstHead ih+         in S.InstSig (getPointLoc l) (maybe [] sContext mctxt) qn ts+     AnnPragma        l ann         ->+        S.AnnPragma (getPointLoc l) (sAnnotation ann)++sAnnotation :: SrcInfo loc => Annotation loc -> S.Annotation+sAnnotation ann = case ann of+    Ann       _ n e   -> S.Ann     (sName n) (sExp e)+    TypeAnn   _ n e   -> S.TypeAnn (sName n) (sExp e)+    ModuleAnn _   e   -> S.ModuleAnn         (sExp e)++sModuleName :: ModuleName l -> S.ModuleName+sModuleName (ModuleName _ str)  = S.ModuleName str++sSpecialCon :: SpecialCon l -> S.SpecialCon+sSpecialCon sc = case sc of+    UnitCon _           -> S.UnitCon+    ListCon _           -> S.ListCon+    FunCon  _           -> S.FunCon+    TupleCon _ b k      -> S.TupleCon b k+    Cons _              -> S.Cons+    UnboxedSingleCon _  -> S.UnboxedSingleCon++sQName :: QName l -> S.QName+sQName qn = case qn of+    Qual    _ mn n  -> S.Qual (sModuleName mn) (sName n)+    UnQual  _    n  -> S.UnQual (sName n)+    Special _ sc    -> S.Special (sSpecialCon sc)++sName :: Name l -> S.Name+sName (Ident _ str) = S.Ident str+sName (Symbol _ str) = S.Symbol str++sIPName :: IPName l -> S.IPName+sIPName (IPDup _ str) = S.IPDup str+sIPName (IPLin _ str) = S.IPLin str++sQOp :: QOp l -> S.QOp+sQOp (QVarOp _ qn) = S.QVarOp (sQName qn)+sQOp (QConOp _ qn) = S.QConOp (sQName qn)++sOp :: Op l -> S.Op+sOp (VarOp _ n) = S.VarOp (sName n)+sOp (ConOp _ n) = S.ConOp (sName n)++sCName :: CName l -> S.CName+sCName (VarName _ n) = S.VarName (sName n)+sCName (ConName _ n) = S.ConName (sName n)++sModuleHead :: Maybe (ModuleHead l) -> (S.ModuleName, Maybe (S.WarningText), Maybe [S.ExportSpec])+sModuleHead mmh = case mmh of+    Nothing -> (S.main_mod, Nothing, Just [S.EVar (S.UnQual S.main_name)])+    Just (ModuleHead _ mn mwt mel) -> (sModuleName mn, fmap sWarningText mwt, fmap sExportSpecList mel)++sExportSpecList :: ExportSpecList l -> [S.ExportSpec]+sExportSpecList (ExportSpecList _ ess) = map sExportSpec ess++sExportSpec :: ExportSpec l -> S.ExportSpec+sExportSpec es = case es of+    EVar _ qn           -> S.EVar (sQName qn)+    EAbs _ qn           -> S.EAbs (sQName qn)+    EThingAll _ qn      -> S.EThingAll (sQName qn)+    EThingWith _ qn cns -> S.EThingWith (sQName qn) (map sCName cns)+    EModuleContents _ mn    -> S.EModuleContents (sModuleName mn)++sImportDecl :: SrcInfo loc => ImportDecl loc -> S.ImportDecl+sImportDecl (ImportDecl l mn qu src mpkg as misl) =+    S.ImportDecl (getPointLoc l) (sModuleName mn) qu src mpkg (fmap sModuleName as) (fmap sImportSpecList misl)++sImportSpecList :: ImportSpecList l -> (Bool, [S.ImportSpec])+sImportSpecList (ImportSpecList _ b iss) = (b, map sImportSpec iss)++sImportSpec :: ImportSpec l -> S.ImportSpec+sImportSpec is = case is of+    IVar _ n            -> S.IVar (sName n)+    IAbs _ n            -> S.IAbs (sName n)+    IThingAll _ n       -> S.IThingAll (sName n)+    IThingWith _ n cns  -> S.IThingWith (sName n) (map sCName cns)++sAssoc :: Assoc l -> S.Assoc+sAssoc a = case a of+    AssocNone  _ -> S.AssocNone+    AssocLeft  _ -> S.AssocLeft+    AssocRight _ -> S.AssocRight++sDeclHead :: DeclHead l -> (S.Name, [S.TyVarBind])+sDeclHead dh = case dh of+    DHead _ n tvs       -> (sName n, map sTyVarBind tvs)+    DHInfix _ tva n tvb -> (sName n, map sTyVarBind [tva,tvb])+    DHParen _ dh        -> sDeclHead dh++sInstHead :: InstHead l -> (S.QName, [S.Type])+sInstHead ih = case ih of+    IHead _ qn ts      -> (sQName qn, map sType ts)+    IHInfix _ ta qn tb -> (sQName qn, map sType [ta,tb])+    IHParen _ ih       -> sInstHead ih++sDataOrNew :: DataOrNew l -> S.DataOrNew+sDataOrNew (DataType _) = S.DataType+sDataOrNew (NewType _) = S.NewType++sDeriving :: (Deriving l) -> [(S.QName, [S.Type])]+sDeriving (Deriving _ ihs) = map sInstHead ihs++sBinds :: SrcInfo loc => Binds loc -> S.Binds+sBinds bs = case bs of+    BDecls  _ decls     -> S.BDecls (map sDecl decls)+    IPBinds _ ipbds     -> S.IPBinds (map sIPBind ipbds)++sIPBind :: SrcInfo loc => IPBind loc -> S.IPBind+sIPBind (IPBind l ipn e) = S.IPBind (getPointLoc l) (sIPName ipn) (sExp e)++sMatch :: SrcInfo loc => Match loc -> S.Match+sMatch (Match l n ps rhs mwhere) =+    S.Match (getPointLoc l) (sName n) (map sPat ps) Nothing (sRhs rhs) (maybe (S.BDecls []) sBinds mwhere)+sMatch (InfixMatch l pa n pbs rhs mwhere) =+    S.Match (getPointLoc l) (sName n) (map sPat (pa:pbs)) Nothing (sRhs rhs) (maybe (S.BDecls []) sBinds mwhere)++sQualConDecl :: SrcInfo loc => QualConDecl loc -> S.QualConDecl+sQualConDecl (QualConDecl l mtvs mctxt cd) =+    S.QualConDecl (getPointLoc l) (maybe [] (map sTyVarBind) mtvs) (maybe [] sContext mctxt) (sConDecl cd)++sConDecl :: ConDecl l -> S.ConDecl+sConDecl cd = case cd of+    ConDecl _ n bts     -> S.ConDecl (sName n) (map sBangType bts)+    InfixConDecl _ bta n btb -> S.InfixConDecl (sBangType bta) (sName n) (sBangType btb)+    RecDecl _ n fds -> S.RecDecl (sName n) (map sFieldDecl fds)++sFieldDecl :: FieldDecl l -> ([S.Name], S.BangType)+sFieldDecl (FieldDecl _ ns bt) = (map sName ns, sBangType bt)++sGadtDecl :: SrcInfo loc => GadtDecl loc -> S.GadtDecl+sGadtDecl (GadtDecl l n t) = S.GadtDecl (getPointLoc l) (sName n) (sType t)++sClassDecl :: SrcInfo loc => ClassDecl loc -> S.ClassDecl+sClassDecl cd = case cd of+    ClsDecl _ d  -> S.ClsDecl (sDecl d)+    ClsDataFam l mctxt dh mk    ->+        let (n, tvs) = sDeclHead dh+         in S.ClsDataFam (getPointLoc l) (maybe [] sContext mctxt) n tvs (fmap sKind mk)+    ClsTyFam l dh mk    ->+        let (n, tvs) = sDeclHead dh+         in S.ClsTyFam (getPointLoc l) n tvs (fmap sKind mk)+    ClsTyDef l t1 t2    ->+        S.ClsTyDef (getPointLoc l) (sType t1) (sType t2)++sInstDecl :: SrcInfo loc => InstDecl loc -> S.InstDecl+sInstDecl id = case id of+    InsDecl   _ d   -> S.InsDecl (sDecl d)+    InsType   l t1 t2   -> S.InsType (getPointLoc l) (sType t1) (sType t2)+    InsData   l dn t constrs mder   ->+        S.InsData (getPointLoc l) (sDataOrNew dn) (sType t) (map sQualConDecl constrs) (maybe [] sDeriving mder)+    InsGData  l dn t mk gds mder    ->+        S.InsGData (getPointLoc l) (sDataOrNew dn) (sType t) (fmap sKind mk) (map sGadtDecl gds) (maybe [] sDeriving mder)+--    InsInline l b mact qn   -> S.InsInline (getPointLoc l) b (maybe S.AlwaysActive sActivation mact) (sQName qn)++sBangType :: BangType l -> S.BangType+sBangType bt = case bt of+    BangedTy   _ t  -> S.BangedTy (sType t)+    UnBangedTy _ t  -> S.UnBangedTy (sType t)+    UnpackedTy _ t  -> S.UnpackedTy (sType t)++sRhs :: SrcInfo loc => Rhs loc -> S.Rhs+sRhs (UnGuardedRhs _ e) = S.UnGuardedRhs (sExp e)+sRhs (GuardedRhss _ grhss) = S.GuardedRhss (map sGuardedRhs grhss)++sGuardedRhs :: SrcInfo loc => GuardedRhs loc -> S.GuardedRhs+sGuardedRhs (GuardedRhs l ss e) = S.GuardedRhs (getPointLoc l) (map sStmt ss) (sExp e)++sType :: Type l -> S.Type+sType t = case t of+    TyForall _ mtvs mctxt t     -> S.TyForall (fmap (map sTyVarBind) mtvs) (maybe [] sContext mctxt) (sType t)+    TyFun _ t1 t2               -> S.TyFun (sType t1) (sType t2)+    TyTuple _ bx ts             -> S.TyTuple bx (map sType ts)+    TyList _ t                  -> S.TyList (sType t)+    TyApp _ t1 t2               -> S.TyApp (sType t1) (sType t2)+    TyVar _ n                   -> S.TyVar (sName n)+    TyCon _ qn                  -> S.TyCon (sQName qn)+    TyParen _ t                 -> S.TyParen (sType t)+    TyInfix _ ta qn tb          -> S.TyInfix (sType ta) (sQName qn) (sType tb)+    TyKind _ t k                -> S.TyKind (sType t) (sKind k)++sTyVarBind :: TyVarBind l -> S.TyVarBind+sTyVarBind (KindedVar _ n k) = S.KindedVar (sName n) (sKind k)+sTyVarBind (UnkindedVar _ n) = S.UnkindedVar (sName n)++sKind :: Kind l -> S.Kind+sKind k = case k of+    KindStar  _     -> S.KindStar+    KindBang  _     -> S.KindBang+    KindFn _ k1 k2  -> S.KindFn (sKind k1) (sKind k2)+    KindParen _ k   -> S.KindParen (sKind k)+    KindVar _ n     -> S.KindVar (sName n)++sFunDep :: FunDep l -> S.FunDep+sFunDep (FunDep _ as bs) = S.FunDep (map sName as) (map sName bs)++sContext :: Context l -> S.Context+sContext ctxt = case ctxt of+    CxSingle _ asst     -> [sAsst asst]+    CxTuple  _ assts    -> map sAsst assts+    CxParen  _ ct       -> sContext ct+    CxEmpty  _          -> []++sAsst :: Asst l -> S.Asst+sAsst asst = case asst of+    ClassA _ qn ts      -> S.ClassA (sQName qn) (map sType ts)+    InfixA _ ta qn tb   -> S.InfixA (sType ta) (sQName qn) (sType tb)+    IParam _ ipn t      -> S.IParam (sIPName ipn) (sType t)+    EqualP _ t1 t2      -> S.EqualP (sType t1) (sType t2)++sLiteral :: Literal l -> S.Literal+sLiteral lit = case lit of+    Char       _ c _ -> S.Char c+    String     _ s _ -> S.String s+    Int        _ i _ -> S.Int i+    Frac       _ r _ -> S.Frac r+    PrimInt    _ i _ -> S.PrimInt i+    PrimWord   _ i _ -> S.PrimWord i+    PrimFloat  _ r _ -> S.PrimFloat r+    PrimDouble _ r _ -> S.PrimDouble r+    PrimChar   _ c _ -> S.PrimChar c+    PrimString _ s _ -> S.PrimString s++sExp :: SrcInfo loc => Exp loc -> S.Exp+sExp e = case e of+    Var _ qn            -> S.Var (sQName qn)+    IPVar _ ipn         -> S.IPVar (sIPName ipn)+    Con _ qn            -> S.Con (sQName qn)+    Lit _ lit           -> S.Lit (sLiteral lit)+    InfixApp _ e1 op e2 -> S.InfixApp (sExp e1) (sQOp op) (sExp e2)+    App _ e1 e2         -> S.App (sExp e1) (sExp e2)+    NegApp _ e          -> S.NegApp (sExp e)+    Lambda l ps e       -> S.Lambda (getPointLoc l) (map sPat ps) (sExp e)+    Let _ bs e          -> S.Let (sBinds bs) (sExp e)+    If _ e1 e2 e3       -> S.If (sExp e1) (sExp e2) (sExp e3)+    Case _ e alts       -> S.Case (sExp e) (map sAlt alts)+    Do _ ss             -> S.Do (map sStmt ss)+    MDo _ ss            -> S.MDo (map sStmt ss)+    Tuple _ bx es       -> S.Tuple bx (map sExp es)+    TupleSection _ bx mes -> S.TupleSection bx (map (fmap sExp) mes)+    List _ es           -> S.List (map sExp es)+    Paren _ e           -> S.Paren (sExp e)+    LeftSection _ e op  -> S.LeftSection (sExp e) (sQOp op)+    RightSection _ op e -> S.RightSection (sQOp op) (sExp e)+    RecConstr _ qn fups -> S.RecConstr (sQName qn) (map sFieldUpdate fups)+    RecUpdate _ e fups  -> S.RecUpdate (sExp e) (map sFieldUpdate fups)+    EnumFrom _ e        -> S.EnumFrom (sExp e)+    EnumFromTo _ e1 e2  -> S.EnumFromTo (sExp e1) (sExp e2)+    EnumFromThen _ e1 e2    -> S.EnumFromThen (sExp e1) (sExp e2)+    EnumFromThenTo _ e1 e2 e3   -> S.EnumFromThenTo (sExp e1) (sExp e2) (sExp e3)+    ListComp _ e qss    -> S.ListComp (sExp e) (map sQualStmt qss)+    ParComp  _ e qsss   -> S.ParComp (sExp e) (map (map sQualStmt) qsss)+    ExpTypeSig l e t    -> S.ExpTypeSig (getPointLoc l) (sExp e) (sType t)+    VarQuote _ qn       -> S.VarQuote (sQName qn)+    TypQuote _ qn       -> S.TypQuote (sQName qn)+    BracketExp _ br     -> S.BracketExp (sBracket br)+    SpliceExp _ sp      -> S.SpliceExp (sSplice sp)+    QuasiQuote _ nm qt  -> S.QuasiQuote nm qt+    XTag l xn attrs mat es  -> S.XTag  (getPointLoc l) (sXName xn) (map sXAttr attrs) (fmap sExp mat) (map sExp es)+    XETag l xn attrs mat    -> S.XETag (getPointLoc l) (sXName xn) (map sXAttr attrs) (fmap sExp mat)+    XPcdata _ str       -> S.XPcdata str+    XExpTag _ e         -> S.XExpTag (sExp e)+    XChildTag l es      -> S.XChildTag (getPointLoc l) (map sExp es)+    CorePragma _ str e  -> S.CorePragma str (sExp e)+    SCCPragma  _ str e  -> S.SCCPragma  str (sExp e)+    GenPragma  _ str i12 i34 e  -> S.GenPragma str i12 i34 (sExp e)+    Proc            l p  e  -> S.Proc (getPointLoc l) (sPat p) (sExp e)+    LeftArrApp      _ e1 e2 -> S.LeftArrApp (sExp e1) (sExp e2)+    RightArrApp     _ e1 e2 -> S.RightArrApp (sExp e1) (sExp e2)+    LeftArrHighApp  _ e1 e2 -> S.LeftArrHighApp (sExp e1) (sExp e2)+    RightArrHighApp _ e1 e2 -> S.RightArrHighApp (sExp e1) (sExp e2)+++sXName :: XName l -> S.XName+sXName (XName _ str) = S.XName str+sXName (XDomName _ dom str) = S.XDomName dom str++sXAttr :: SrcInfo loc => XAttr loc -> S.XAttr+sXAttr (XAttr _ xn e) = S.XAttr (sXName xn) (sExp e)++sBracket:: SrcInfo loc => Bracket loc -> S.Bracket+sBracket br = case br of+    ExpBracket _ e  -> S.ExpBracket (sExp e)+    PatBracket _ p  -> S.PatBracket (sPat p)+    TypeBracket _ t -> S.TypeBracket (sType t)+    DeclBracket _ ds -> S.DeclBracket (map sDecl ds)++sSplice :: SrcInfo loc => Splice loc -> S.Splice+sSplice (IdSplice _ str) = S.IdSplice str+sSplice (ParenSplice _ e) = S.ParenSplice (sExp e)++sSafety :: Safety l -> S.Safety+sSafety (PlayRisky _) = S.PlayRisky+sSafety (PlaySafe _ b) = S.PlaySafe b+sSafety (PlayInterruptible _) = S.PlayInterruptible++sCallConv :: CallConv l -> S.CallConv+sCallConv (StdCall   _) = S.StdCall+sCallConv (CCall     _) = S.CCall+sCallConv (CPlusPlus _) = S.CPlusPlus+sCallConv (DotNet    _) = S.DotNet+sCallConv (Jvm       _) = S.Jvm+sCallConv (Js        _) = S.Js+sCallConv (CApi      _) = S.CApi++sModulePragma :: SrcInfo loc => ModulePragma loc -> S.ModulePragma+sModulePragma pr = case pr of+    LanguagePragma   l ns   -> S.LanguagePragma (getPointLoc l) (map sName ns)+    OptionsPragma    l mt str -> S.OptionsPragma (getPointLoc l) mt str+    AnnModulePragma  l ann -> S.AnnModulePragma (getPointLoc l) (sAnnotation ann)++sActivation :: Activation l -> S.Activation+sActivation act = case act of+    ActiveFrom   _ k    -> S.ActiveFrom k+    ActiveUntil  _ k    -> S.ActiveUntil k++sRule :: SrcInfo loc => Rule loc -> S.Rule+sRule (Rule _ str mact mrvs e1 e2) =+    S.Rule str (maybe S.AlwaysActive sActivation mact) (fmap (map sRuleVar) mrvs) (sExp e1) (sExp e2)++sRuleVar :: RuleVar l -> S.RuleVar+sRuleVar (RuleVar _ n) = S.RuleVar (sName n)+sRuleVar (TypedRuleVar _ n t) = S.TypedRuleVar (sName n) (sType t)++sWarningText :: WarningText l -> S.WarningText+sWarningText (DeprText _ str) = S.DeprText str+sWarningText (WarnText _ str) = S.WarnText str++sPat :: SrcInfo loc => Pat loc -> S.Pat+sPat pat = case pat of+    PVar _ n            -> S.PVar (sName n)+    PLit _ lit          -> S.PLit (sLiteral lit)+    PNeg _ p            -> S.PNeg (sPat p)+    PNPlusK _ n k       -> S.PNPlusK (sName n) k+    PInfixApp _ pa qn pb -> S.PInfixApp (sPat pa) (sQName qn) (sPat pb)+    PApp _ qn ps        -> S.PApp (sQName qn) (map sPat ps)+    PTuple _ bx ps      -> S.PTuple bx (map sPat ps)+    PList _ ps          -> S.PList (map sPat ps)+    PParen _ p          -> S.PParen (sPat p)+    PRec _ qn pfs       -> S.PRec (sQName qn) (map sPatField pfs)+    PAsPat _ n p        -> S.PAsPat (sName n) (sPat p)+    PWildCard _         -> S.PWildCard+    PIrrPat _ p         -> S.PIrrPat (sPat p)+    PatTypeSig l p t    -> S.PatTypeSig (getPointLoc l) (sPat p) (sType t)+    PViewPat _ e p      -> S.PViewPat (sExp e) (sPat p)+    PRPat _ rps         -> S.PRPat (map sRPat rps)+    PXTag l xn attrs mat ps -> S.PXTag (getPointLoc l) (sXName xn) (map sPXAttr attrs) (fmap sPat mat) (map sPat ps)+    PXETag l xn attrs mat   -> S.PXETag (getPointLoc l) (sXName xn) (map sPXAttr attrs) (fmap sPat mat)+    PXPcdata _ str      -> S.PXPcdata str+    PXPatTag _ p        -> S.PXPatTag (sPat p)+    PXRPats  _ rps      -> S.PXRPats (map sRPat rps)+    PExplTypeArg _ qn t -> S.PExplTypeArg (sQName qn) (sType t)+    PQuasiQuote _ nm qt -> S.PQuasiQuote nm qt+    PBangPat _ p        -> S.PBangPat (sPat p)++sPXAttr :: SrcInfo loc => PXAttr loc -> S.PXAttr+sPXAttr (PXAttr _ xn p) = S.PXAttr (sXName xn) (sPat p)++sRPatOp :: RPatOp l -> S.RPatOp+sRPatOp rpop = case rpop of+    RPStar  _ -> S.RPStar+    RPStarG _ -> S.RPStarG+    RPPlus  _ -> S.RPPlus+    RPPlusG _ -> S.RPPlusG+    RPOpt   _ -> S.RPOpt+    RPOptG  _ -> S.RPOptG++sRPat :: SrcInfo loc => RPat loc -> S.RPat+sRPat rp = case rp of+    RPOp _ rp rop       -> S.RPOp (sRPat rp) (sRPatOp rop)+    RPEither _ rp1 rp2  -> S.RPEither (sRPat rp1) (sRPat rp2)+    RPSeq _ rps         -> S.RPSeq (map sRPat rps)+    RPGuard _ p ss      -> S.RPGuard (sPat p) (map sStmt ss)+    RPCAs _ n rp        -> S.RPCAs (sName n) (sRPat rp)+    RPAs _ n rp         -> S.RPAs (sName n) (sRPat rp)+    RPParen _ rp        -> S.RPParen (sRPat rp)+    RPPat _ p           -> S.RPPat (sPat p)++sPatField :: SrcInfo loc => PatField loc -> S.PatField+sPatField pf = case pf of+    PFieldPat _ qn p    -> S.PFieldPat (sQName qn) (sPat p)+    PFieldPun _ n       -> S.PFieldPun (sName n)+    PFieldWildcard _    -> S.PFieldWildcard++sStmt :: SrcInfo loc => Stmt loc -> S.Stmt+sStmt stmt = case stmt of+    Generator l p e     -> S.Generator (getPointLoc l) (sPat p) (sExp e)+    Qualifier _ e       -> S.Qualifier (sExp e)+    LetStmt _ bs        -> S.LetStmt (sBinds bs)+    RecStmt _ ss        -> S.RecStmt (map sStmt ss)++sQualStmt :: SrcInfo loc => QualStmt loc -> S.QualStmt+sQualStmt qs = case qs of+    QualStmt     _ stmt     -> S.QualStmt (sStmt stmt)+    ThenTrans    _ e        -> S.ThenTrans (sExp e)+    ThenBy       _ e1 e2    -> S.ThenBy (sExp e1) (sExp e2)+    GroupBy      _ e        -> S.GroupBy (sExp e)+    GroupUsing   _ e        -> S.GroupUsing (sExp e)+    GroupByUsing _ e1 e2    -> S.GroupByUsing (sExp e1) (sExp e2)++sFieldUpdate :: SrcInfo loc => FieldUpdate loc -> S.FieldUpdate+sFieldUpdate fu = case fu of+    FieldUpdate _ qn e      -> S.FieldUpdate (sQName qn) (sExp e)+    FieldPun _ n            -> S.FieldPun (sName n)+    FieldWildcard _         -> S.FieldWildcard++sAlt :: SrcInfo loc => Alt loc -> S.Alt+sAlt (Alt l p galts mbs) = S.Alt (getPointLoc l) (sPat p) (sGuardedAlts galts) (maybe (S.BDecls []) sBinds mbs)++sGuardedAlts :: SrcInfo loc => GuardedAlts loc -> S.GuardedAlts+sGuardedAlts galts = case galts of+    UnGuardedAlt _ e    -> S.UnGuardedAlt (sExp e)+    GuardedAlts  _ gs   -> S.GuardedAlts (map sGuardedAlt gs)++sGuardedAlt :: SrcInfo loc => GuardedAlt loc -> S.GuardedAlt+sGuardedAlt (GuardedAlt l ss e) = S.GuardedAlt (getPointLoc l) (map sStmt ss) (sExp e)
src/Language/Haskell/Exts/Annotated/Syntax.hs view
@@ -1,4 +1,4 @@-{-# LANGUAGE CPP, DeriveDataTypeable #-}+{-# LANGUAGE CPP, DeriveDataTypeable, DeriveFoldable, DeriveTraversable #-} ----------------------------------------------------------------------------- -- | -- Module      :  Language.Haskell.Exts.Annotated.Syntax@@ -90,7 +90,7 @@     unit_con, tuple_con, unboxed_singleton_con,     -- ** Special identifiers     as_name, qualified_name, hiding_name, minus_name, bang_name, dot_name, star_name,-    export_name, safe_name, unsafe_name, threadsafe_name, +    export_name, safe_name, unsafe_name, threadsafe_name,     stdcall_name, ccall_name, cplusplus_name, dotnet_name, jvm_name, js_name,     forall_name, family_name,     -- ** Type constructors@@ -113,11 +113,13 @@ #endif #endif +import Data.Foldable (Foldable)+import Data.Traversable (Traversable)  -- | The name of a Haskell module. data ModuleName l = ModuleName l String #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -134,7 +136,7 @@     | Cons l                -- ^ list data constructor @(:)@     | UnboxedSingleCon l    -- ^ unboxed singleton tuple constructor @(\# \#)@ #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -146,7 +148,7 @@     | UnQual  l                (Name l) -- ^ unqualified local name     | Special l (SpecialCon l)          -- ^ built-in constructor with special syntax #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -156,7 +158,7 @@     = Ident  l String   -- ^ /varid/ or /conid/.     | Symbol l String   -- ^ /varsym/ or /consym/ #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -166,7 +168,7 @@     = IPDup l String -- ^ ?/ident/, non-linear implicit parameter     | IPLin l String -- ^ %/ident/, linear implicit parameter #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -176,7 +178,7 @@     = QVarOp l (QName l) -- ^ variable operator (/qvarop/)     | QConOp l (QName l) -- ^ constructor operator (/qconop/) #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -186,7 +188,7 @@     = VarOp l (Name l)    -- ^ variable operator (/varop/)     | ConOp l (Name l)    -- ^ constructor operator (/conop/) #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -197,7 +199,7 @@     = VarName l (Name l) -- ^ name of a method or field     | ConName l (Name l) -- ^ name of a data constructor #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -213,7 +215,7 @@                 (XName l) [XAttr l] (Maybe (Exp l)) [Exp l]     -- ^ a hybrid module combining an XML document with an ordinary module #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -221,7 +223,7 @@ -- | The head of a module, including the name and export specification. data ModuleHead l = ModuleHead l (ModuleName l) (Maybe (WarningText l)) (Maybe (ExportSpecList l)) #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -230,7 +232,7 @@ data ExportSpecList l     = ExportSpecList l [ExportSpec l] #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -250,7 +252,7 @@      | EModuleContents l (ModuleName l) -- ^ @module M@:                                         --   re-export a module. #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -267,7 +269,7 @@             -- ^ optional list of import specifications.     } #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -279,7 +281,7 @@             -- The 'Bool' is 'True' if the names are excluded             -- by @hiding@. #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -297,7 +299,7 @@                                         --   a class imported with some of its methods, or                                         --   a datatype imported with some of its constructors. #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -308,7 +310,7 @@      | AssocLeft  l -- ^ left-associative operator (declared with @infixl@).      | AssocRight l -- ^ right-associative operator (declared with @infixr@) #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -363,7 +365,7 @@      -- ^ An INLINE pragma      | InlineConlikeSig l      (Maybe (Activation l)) (QName l)      -- ^ An INLINE CONLIKE pragma-     | SpecSig          l                             (QName l) [Type l]+     | SpecSig          l      (Maybe (Activation l)) (QName l) [Type l]      -- ^ A SPECIALISE pragma      | SpecInlineSig    l Bool (Maybe (Activation l)) (QName l) [Type l]      -- ^ A SPECIALISE INLINE pragma@@ -372,7 +374,7 @@      | AnnPragma        l (Annotation l)      -- ^ An ANN pragma #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -386,7 +388,7 @@     | ModuleAnn l           (Exp l)     -- ^ An annotation for the defining module. #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -395,7 +397,7 @@ -- | A flag stating whether a declaration is a data or newtype declaration. data DataOrNew l = DataType l | NewType l #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -406,7 +408,7 @@     | DHInfix l (TyVarBind l) (Name l) (TyVarBind l)     | DHParen l (DeclHead l) #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -417,7 +419,7 @@     | IHInfix l (Type l) (QName l) (Type l)     | IHParen l (InstHead l) #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -425,7 +427,7 @@ -- | A deriving clause following a data type declaration. data Deriving l = Deriving l [InstHead l] #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -435,7 +437,7 @@     = BDecls  l [Decl l]     -- ^ An ordinary binding group     | IPBinds l [IPBind l]   -- ^ A binding group for implicit parameters #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -443,7 +445,7 @@ -- | A binding of an implicit parameter. data IPBind l = IPBind l (IPName l) (Exp l) #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -451,7 +453,7 @@ -- | Clauses of a function binding. data Match l      = Match l      (Name l) [Pat l]         (Rhs l) {-where-} (Maybe (Binds l))-        -- ^ A clause defined with prefix notation, i.e. the function name +        -- ^ A clause defined with prefix notation, i.e. the function name         --  followed by its argument patterns, the right-hand side and an         --  optional where clause.      | InfixMatch l (Pat l) (Name l) [Pat l] (Rhs l) {-where-} (Maybe (Binds l))@@ -461,7 +463,7 @@         --  Note that there can be more than two arguments to a function declared         --  infix, hence the list of pattern arguments. #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -473,7 +475,7 @@         {-forall-} (Maybe [TyVarBind l]) {- . -} (Maybe (Context l))         {- => -} (ConDecl l) #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -487,7 +489,7 @@      | RecDecl l (Name l) [FieldDecl l]                 -- ^ record constructor #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -495,7 +497,7 @@ -- | Declaration of a (list of) named field(s). data FieldDecl l = FieldDecl l [Name l] (BangType l) #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -505,7 +507,7 @@ data GadtDecl l     = GadtDecl l (Name l) (Type l) #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -521,7 +523,7 @@     | ClsTyDef   l (Type l) (Type l)             -- ^ default choice for an associated type synonym #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -537,7 +539,7 @@     | InsGData  l (DataOrNew l) (Type l) (Maybe (Kind l)) [GadtDecl l] (Maybe (Deriving l))             -- ^ an associated data type implemented using GADT style #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -549,7 +551,7 @@      | UnBangedTy l (Type l) -- ^ non-strict component      | UnpackedTy l (Type l) -- ^ unboxed component, marked with an UNPACK pragma #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -560,7 +562,7 @@      | GuardedRhss  l [GuardedRhs l]                 -- ^ guarded right hand side (/gdrhs/) #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -571,7 +573,7 @@ data GuardedRhs l      = GuardedRhs l [Stmt l] (Exp l) #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -593,7 +595,7 @@      | TyInfix l (Type l) (QName l) (Type l)    -- ^ infix type constructor      | TyKind  l (Type l) (Kind l)              -- ^ type with explicit kind signature #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -611,7 +613,7 @@     = KindedVar   l (Name l) (Kind l)  -- ^ variable binding with kind annotation     | UnkindedVar l (Name l)           -- ^ ordinary variable binding #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -624,7 +626,7 @@     | KindParen l (Kind l)           -- ^ a parenthesised kind     | KindVar   l (Name l)           -- ^ a kind variable (as-of-yet unsupported by compilers) #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -635,7 +637,7 @@ data FunDep l     = FunDep l [Name l] [Name l] #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -647,7 +649,7 @@     | CxParen  l (Context l)     | CxEmpty  l #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -662,7 +664,7 @@         | IParam l (IPName l) (Type l)          -- ^ implicit parameter assertion         | EqualP l (Type l) (Type l)            -- ^ type equality constraint #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -683,7 +685,7 @@     | PrimChar   l Char     String     -- ^ unboxed character literal     | PrimString l String   String     -- ^ unboxed string literal #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -705,8 +707,8 @@                                             --   the last statement in the list                                             --   should be an expression.     | MDo l [Stmt l]                        -- ^ @mdo@-expression-    | Tuple l [Exp l]                       -- ^ tuple expression-    | TupleSection l [Maybe (Exp l)]        -- ^ tuple section expression, e.g. @(,,3)@+    | Tuple l Boxed [Exp l]                 -- ^ tuple expression+    | TupleSection l Boxed [Maybe (Exp l)]  -- ^ tuple section expression, e.g. @(,,3)@     | List l [Exp l]                        -- ^ list expression     | Paren l (Exp l)                       -- ^ parenthesised expression     | LeftSection l (Exp l) (QOp l)         -- ^ left section @(@/exp/ /qop/@)@@@ -739,7 +741,7 @@                                             -- ^ empty xml element, with attributes     | XPcdata l String                      -- ^ PCDATA child element     | XExpTag l (Exp l)                     -- ^ escaped haskell expression inside xml-    | XChildTag l [Exp l]                   -- ^ children of an xml element    +    | XChildTag l [Exp l]                   -- ^ children of an xml element   -- Pragmas@@ -755,7 +757,7 @@     | LeftArrHighApp  l (Exp l) (Exp l)     -- ^ higher-order arrow application (from left): /exp/ @-<<@ /exp/     | RightArrHighApp l (Exp l) (Exp l)     -- ^ higher-order arrow application (from right): /exp/ @>>-@ /exp/ #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -766,7 +768,7 @@     = XName l String              -- <name ...     | XDomName l String String    -- <dom:name ... #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -774,7 +776,7 @@ -- | An xml attribute, which is a name-expression pair. data XAttr l = XAttr l (XName l) (Exp l) #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -786,7 +788,7 @@     | TypeBracket l (Type l)      -- ^ type bracket: @[t| ... |]@     | DeclBracket l [Decl l]      -- ^ declaration bracket: @[d| ... |]@ #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -796,7 +798,7 @@     = IdSplice l String           -- ^ variable splice: @$var@     | ParenSplice l (Exp l)       -- ^ parenthesised expression splice: @$(/exp/)@ #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -805,8 +807,9 @@ data Safety l     = PlayRisky l         -- ^ unsafe     | PlaySafe l Bool     -- ^ safe ('False') or threadsafe ('True')+    | PlayInterruptible l -- ^ interruptible #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -819,8 +822,9 @@     | DotNet l     | Jvm l     | Js l+    | CApi l #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -833,7 +837,7 @@     | AnnModulePragma  l (Annotation l)                         -- ^ ANN pragma with module scope #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -851,7 +855,7 @@     = ActiveFrom   l Int     | ActiveUntil  l Int #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -860,7 +864,7 @@ data Rule l     = Rule l String (Maybe (Activation l)) (Maybe [RuleVar l]) (Exp l) (Exp l) #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -870,7 +874,7 @@     = RuleVar l (Name l)     | TypedRuleVar l (Name l) (Type l) #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -881,7 +885,7 @@     = DeprText l String     | WarnText l String #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -895,7 +899,7 @@     | PNPlusK l (Name l) Integer            -- ^ n+k pattern     | PInfixApp l (Pat l) (QName l) (Pat l) -- ^ pattern with an infix data constructor     | PApp l (QName l) [Pat l]              -- ^ data constructor and argument patterns-    | PTuple l [Pat l]                      -- ^ tuple pattern+    | PTuple l Boxed [Pat l]                -- ^ tuple pattern     | PList l [Pat l]                       -- ^ list pattern     | PParen l (Pat l)                      -- ^ parenthesized pattern     | PRec l (QName l) [PatField l]         -- ^ labelled pattern, record style@@ -916,7 +920,7 @@     | PQuasiQuote l String String           -- ^ quasi quote pattern: @[$/name/| /string/ |]@     | PBangPat l (Pat l)                    -- ^ strict (bang) pattern: @f !x = ...@ #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -924,7 +928,7 @@ -- | An XML attribute in a pattern. data PXAttr l = PXAttr l (XName l) (Pat l) #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -938,7 +942,7 @@     | RPOpt   l  -- ^ @?@ = 0 or 1     | RPOptG  l  -- ^ @?!@ = 0 or 1, greedy #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -954,7 +958,7 @@     | RPParen l (RPat l)           -- ^ parenthesised pattern, e.g. (2*)     | RPPat l (Pat l)              -- ^ an ordinary pattern #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -965,7 +969,7 @@     | PFieldPun l (Name l)              -- ^ record field pun     | PFieldWildcard l                  -- ^ record field wildcard #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -983,7 +987,7 @@     | LetStmt l (Binds l)   -- ^ local bindings     | RecStmt l [Stmt l]    -- ^ a recursive binding group for arrows #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -999,7 +1003,7 @@     | GroupUsing   l (Exp l)          -- ^ @then@ @group@ @using@ /exp/     | GroupByUsing l (Exp l) (Exp l)  -- ^ @then@ @group@ @by@ /exp/ @using@ /exp/ #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -1010,7 +1014,7 @@     | FieldPun l (Name l)                -- ^ record field pun     | FieldWildcard l                    -- ^ record field wildcard #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -1019,7 +1023,7 @@ data Alt l     = Alt l (Pat l) (GuardedAlts l) (Maybe (Binds l)) #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -1031,7 +1035,7 @@     = UnGuardedAlt l (Exp l)         -- ^ @->@ /exp/     | GuardedAlts  l [GuardedAlt l]  -- ^ /gdpat/ #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -1040,7 +1044,7 @@ data GuardedAlt l     = GuardedAlt l [Stmt l] (Exp l) #ifdef __GLASGOW_HASKELL__-  deriving (Eq,Ord,Show,Typeable,Data)+  deriving (Eq,Ord,Show,Typeable,Data,Foldable,Traversable) #else   deriving (Eq,Ord,Show) #endif@@ -1085,8 +1089,8 @@ dot_name       l = Symbol l "." star_name      l = Symbol l "*" -export_name, safe_name, unsafe_name, threadsafe_name, -  stdcall_name, ccall_name, cplusplus_name, dotnet_name, +export_name, safe_name, unsafe_name, threadsafe_name,+  stdcall_name, ccall_name, cplusplus_name, dotnet_name,   jvm_name, js_name, forall_name, family_name :: l -> Name l export_name     l = Ident l "export" safe_name       l = Ident l "safe"@@ -1236,7 +1240,7 @@         InlineSig        l b mact qn      -> InlineSig (f l) b (fmap (fmap f) mact) (fmap f qn)         InlineConlikeSig l   mact qn      -> InlineConlikeSig (f l) (fmap (fmap f) mact) (fmap f qn)         SpecInlineSig    l b mact qn ts   -> SpecInlineSig (f l) b (fmap (fmap f) mact) (fmap f qn) (map (fmap f) ts)-        SpecSig          l        qn ts   -> SpecSig (f l) (fmap f qn) (map (fmap f) ts)+        SpecSig          l   mact qn ts   -> SpecSig       (f l)   (fmap (fmap f) mact) (fmap f qn) (map (fmap f) ts)         InstSig          l mcx ih         -> InstSig (f l) (fmap (fmap f) mcx) (fmap f ih)         AnnPragma        l ann            -> AnnPragma (f l) (fmap f ann)       where wp f (ns, s) = (map (fmap f) ns, s)@@ -1386,8 +1390,8 @@         Case l e alts   -> Case (f l) (fmap f e) (map (fmap f) alts)         Do l ss         -> Do (f l) (map (fmap f) ss)         MDo l ss        -> MDo (f l) (map (fmap f) ss)-        Tuple l es      -> Tuple (f l) (map (fmap f) es)-        TupleSection l mes  -> TupleSection (f l) (map (fmap (fmap f)) mes)+        Tuple l bx es   -> Tuple (f l) bx (map (fmap f) es)+        TupleSection l bx mes -> TupleSection (f l) bx (map (fmap (fmap f)) mes)         List l es       -> List (f l) (map (fmap f) es)         Paren l e       -> Paren (f l) (fmap f e)         LeftSection l e qop     -> LeftSection (f l) (fmap f e) (fmap f qop)@@ -1443,10 +1447,16 @@ instance Functor Safety where     fmap f (PlayRisky l) = PlayRisky (f l)     fmap f (PlaySafe l b) = PlaySafe (f l) b+    fmap f (PlayInterruptible l) = PlayInterruptible (f l)  instance Functor CallConv where     fmap f (StdCall l) = StdCall (f l)     fmap f (CCall l) = CCall (f l)+    fmap f (CPlusPlus l) = CPlusPlus (f l)+    fmap f (DotNet l) = DotNet (f l)+    fmap f (Jvm l) = Jvm (f l)+    fmap f (Js l) = Js (f l)+    fmap f (CApi l) = CApi (f l)  instance Functor ModulePragma where     fmap f (LanguagePragma   l ns) = LanguagePragma (f l) (map (fmap f) ns)@@ -1477,7 +1487,7 @@       PNPlusK l n k     -> PNPlusK (f l) (fmap f n) k       PInfixApp l pa qn pb  -> PInfixApp (f l) (fmap f pa) (fmap f qn) (fmap f pb)       PApp l qn ps      -> PApp (f l) (fmap f qn) (map (fmap f) ps)-      PTuple l ps       -> PTuple (f l) (map (fmap f) ps)+      PTuple l bx ps    -> PTuple (f l) bx (map (fmap f) ps)       PList l ps        -> PList (f l) (map (fmap f) ps)       PParen l p        -> PParen (f l) (fmap f p)       PRec l qn pfs     -> PRec (f l) (fmap f qn) (map (fmap f) pfs)@@ -1707,7 +1717,7 @@         WarnPragmaDecl   l nss          -> l         InlineSig        l b act qn     -> l         InlineConlikeSig l   act qn     -> l-        SpecSig          l qn ts        -> l+        SpecSig          l   act qn ts  -> l         SpecInlineSig    l b act qn ts  -> l         InstSig          l cx ih        -> l         AnnPragma        l ann          -> l@@ -1738,7 +1748,7 @@         WarnPragmaDecl   l nss           -> WarnPragmaDecl (f l) nss         InlineSig        l b act qn      -> InlineSig (f l) b act qn         InlineConlikeSig l   act qn      -> InlineConlikeSig (f l) act qn-        SpecSig          l qn ts         -> SpecSig (f l) qn ts+        SpecSig          l   act qn ts   -> SpecSig       (f l)   act qn ts         SpecInlineSig    l b act qn ts   -> SpecInlineSig (f l) b act qn ts         InstSig          l mcx ih        -> InstSig (f l) mcx ih         AnnPragma        l ann           -> AnnPragma (f l) ann@@ -1750,7 +1760,7 @@     amap f (Ann     l n e) = Ann     (f l) n e     amap f (TypeAnn l n e) = TypeAnn (f l) n e     amap f (ModuleAnn l e) = ModuleAnn (f l) e-    + instance Annotated DataOrNew where     ann (DataType l) = l     ann (NewType  l) = l@@ -1947,8 +1957,8 @@         Case l e alts   -> l         Do l ss         -> l         MDo l ss        -> l-        Tuple l es      -> l-        TupleSection l mes  -> l+        Tuple l bx es   -> l+        TupleSection l bx mes -> l         List l es       -> l         Paren l e       -> l         LeftSection l e qop     -> l@@ -1998,8 +2008,8 @@         Case l e alts   -> Case (f l) e alts         Do l ss         -> Do (f l) ss         MDo l ss        -> MDo (f l) ss-        Tuple l es      -> Tuple (f l) es-        TupleSection l mes  -> TupleSection (f l) mes+        Tuple l bx es   -> Tuple (f l) bx es+        TupleSection l bx mes -> TupleSection (f l) bx mes         List l es       -> List (f l) es         Paren l e       -> Paren (f l) e         LeftSection l e qop     -> LeftSection (f l) e qop@@ -2064,11 +2074,17 @@ instance Annotated Safety where     ann (PlayRisky l) = l     ann (PlaySafe l b) = l+    ann (PlayInterruptible l) = l     amap = fmap  instance Annotated CallConv where     ann (StdCall l) = l     ann (CCall l) = l+    ann (CPlusPlus l) = l+    ann (DotNet l) = l+    ann (Jvm l) = l+    ann (Js l) = l+    ann (CApi l) = l     amap = fmap  instance Annotated ModulePragma where@@ -2107,7 +2123,7 @@       PNPlusK l n k     -> l       PInfixApp l pa qn pb  -> l       PApp l qn ps      -> l-      PTuple l ps       -> l+      PTuple l bx ps    -> l       PList l ps        -> l       PParen l p        -> l       PRec l qn pfs     -> l@@ -2132,7 +2148,7 @@       PNPlusK l n k     -> PNPlusK (f l) n k       PInfixApp l pa qn pb  -> PInfixApp (f l) pa qn pb       PApp l qn ps      -> PApp (f l) qn ps-      PTuple l ps       -> PTuple (f l) ps+      PTuple l bx ps    -> PTuple (f l) bx ps       PList l ps        -> PList (f l) ps       PParen l p        -> PParen (f l) p       PRec l qn pfs     -> PRec (f l) qn pfs
src/Language/Haskell/Exts/Build.hs view
@@ -120,11 +120,11 @@  -- | A tuple expression. tuple :: [Exp] -> Exp-tuple = Tuple+tuple = Tuple Boxed  -- | A tuple pattern. pTuple :: [Pat] -> Pat-pTuple = PTuple+pTuple = PTuple Boxed  -- | A tuple expression consisting of variables only. varTuple :: [Name] -> Exp
src/Language/Haskell/Exts/Comments.hs view
@@ -1,20 +1,20 @@-{-# LANGUAGE CPP, DeriveDataTypeable #-}
-module Language.Haskell.Exts.Comments where
-
-import Language.Haskell.Exts.SrcLoc
-
-#ifdef __GLASGOW_HASKELL__
-#ifdef BASE4
-import Data.Data
-#else
-import Data.Generics (Data(..),Typeable(..))
-#endif
-#endif
-
--- | A Haskell comment. The 'Bool' is 'True' if the comment is multi-line, i.e. @{- -}@.
-data Comment = Comment Bool SrcSpan String
-#ifdef __GLASGOW_HASKELL__
-  deriving (Eq,Show,Typeable,Data)
-#else
-  deriving (Eq,Show)
-#endif
+{-# LANGUAGE CPP, DeriveDataTypeable #-}+module Language.Haskell.Exts.Comments where++import Language.Haskell.Exts.SrcLoc++#ifdef __GLASGOW_HASKELL__+#ifdef BASE4+import Data.Data+#else+import Data.Generics (Data(..),Typeable(..))+#endif+#endif++-- | A Haskell comment. The 'Bool' is 'True' if the comment is multi-line, i.e. @{- -}@.+data Comment = Comment Bool SrcSpan String+#ifdef __GLASGOW_HASKELL__+  deriving (Eq,Show,Typeable,Data)+#else+  deriving (Eq,Show)+#endif
src/Language/Haskell/Exts/ExtScheme.hs view
@@ -1,37 +1,37 @@-{-# OPTIONS_HADDOCK hide #-}
------------------------------------------------------------------------------
--- |
--- Module      :  Language.Haskell.Exts.ExtScheme
--- Copyright   :  (c) Niklas Broberg 2009
--- License     :  BSD-style (see the file LICENSE.txt)
---
--- Maintainer  :  Niklas Broberg, d00nibro@chalmers.se
--- Stability   :  stable
--- Portability :  portable
---
--- Internal scheme for handling extensions in a
--- convenient fashion.
---
------------------------------------------------------------------------------
-module Language.Haskell.Exts.ExtScheme where
-
-import Language.Haskell.Exts.Extension
-
-data ExtScheme = Any [Extension] | All [Extension]
-  deriving (Eq,Show)
-
-type MExtScheme = Maybe ExtScheme
-
-class Enabled a where
-  isEnabled :: a -> [Extension] -> Bool
-
-instance Enabled Extension where
-  isEnabled = elem
-
-instance Enabled ExtScheme where
-  isEnabled (Any exts) enabled = any (`elem` enabled) exts
-  isEnabled (All exts) enabled = all (`elem` enabled) exts
-
-instance Enabled a => Enabled (Maybe a) where
-  isEnabled Nothing  = const True
-  isEnabled (Just a) = isEnabled a
+{-# OPTIONS_HADDOCK hide #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  Language.Haskell.Exts.ExtScheme+-- Copyright   :  (c) Niklas Broberg 2009+-- License     :  BSD-style (see the file LICENSE.txt)+--+-- Maintainer  :  Niklas Broberg, d00nibro@chalmers.se+-- Stability   :  stable+-- Portability :  portable+--+-- Internal scheme for handling extensions in a+-- convenient fashion.+--+-----------------------------------------------------------------------------+module Language.Haskell.Exts.ExtScheme where++import Language.Haskell.Exts.Extension++data ExtScheme = Any [KnownExtension] | All [KnownExtension]+  deriving (Eq,Show)++type MExtScheme = Maybe ExtScheme++class Enabled a where+  isEnabled :: a -> [KnownExtension] -> Bool++instance Enabled KnownExtension where+  isEnabled = elem++instance Enabled ExtScheme where+  isEnabled (Any exts) enabled = any (`elem` enabled) exts+  isEnabled (All exts) enabled = all (`elem` enabled) exts++instance Enabled a => Enabled (Maybe a) where+  isEnabled Nothing  = const True+  isEnabled (Just a) = isEnabled a
src/Language/Haskell/Exts/Extension.hs view
@@ -1,264 +1,667 @@------------------------------------------------------------------------------
--- |
--- Module      :  Language.Haskell.Exts.Extension
--- Copyright   :  (c) Niklas Broberg 2009
--- License     :  BSD-style (see the file LICENSE.txt)
---
--- Maintainer  :  Niklas Broberg, d00nibro@chalmers.se
--- Stability   :  transient
--- Portability :  portable
---
--- This entire module should be replaced with
--- Language.Haskell.Extension from cabal, but we must
--- wait for a release of cabal that includes the
--- 'XmlSyntax' and 'RegularPatterns' extensions.
---
------------------------------------------------------------------------------
-module Language.Haskell.Exts.Extension (
-    -- * Extensions
-    Extension(..), classifyExtension, impliesExts,
-
-    -- * Extension groups
-    haskell98, haskell2010,
-
-    glasgowExts, knownExtensions
-
-    ) where
-
-
--- | This datatype is a copy of the one in Cabal's Language.Haskell.Extension module.
---   The intention is to eventually import it from Cabal, but we need to wait for
---   the next release of Cabal which includes XmlSyntax and RegularPatterns.
-data Extension
-  = OverlappingInstances
-  | UndecidableInstances
-  | IncoherentInstances
-  | RecursiveDo
-  | ParallelListComp
-  | MultiParamTypeClasses
-  | NoMonomorphismRestriction
-  | FunctionalDependencies
-  | ExplicitForAll
-  | Rank2Types
-  | RankNTypes
-  | PolymorphicComponents
-  | ExistentialQuantification
-  | ScopedTypeVariables
-  | ImplicitParams
-  | FlexibleContexts
-  | FlexibleInstances
-  | EmptyDataDecls
-  | CPP
-
-  | KindSignatures
-  | BangPatterns
-  | TypeSynonymInstances
-  | TemplateHaskell
-  | ForeignFunctionInterface
-  | Arrows
-  | Generics
-  | NoImplicitPrelude
-  | NamedFieldPuns
-  | PatternGuards
-  | GeneralizedNewtypeDeriving
-
-  | ExtensibleRecords
-  | RestrictedTypeSynonyms
-  | HereDocuments
-  | MagicHash
-  | TypeFamilies
-  | StandaloneDeriving
-
-  | UnicodeSyntax
-  | PatternSignatures
-  | UnliftedFFITypes
-  | LiberalTypeSynonyms
-  | TypeOperators
-  | RecordWildCards
-  | RecordPuns -- should be deprecated
-  | DisambiguateRecordFields
-  | OverloadedStrings
-  | GADTs
-  | MonoPatBinds
-  | NoMonoPatBinds -- should be deprecated
-  | RelaxedPolyRec
-  | ExtendedDefaultRules
-  | UnboxedTuples
-  | DeriveDataTypeable
-  | ConstrainedClassMethods
-  | NPlusKPatterns
-
-  | PackageImports
-  | DoAndIfThenElse
-
-  | ImpredicativeTypes
-  | NewQualifiedOperators
-  | PostfixOperators
-  | QuasiQuotes
-  | TransformListComp
-  | ViewPatterns
-
-  | XmlSyntax
-
-  | RegularPatterns
-
-  | TupleSections
-
-  | UnknownExtension String
-  deriving (Eq, Ord, Show, Read)
-
-
--- | Certain extensions imply other extensions, and this function
---   makes the implication explicit. This also handles deprecated
---   extensions, which imply their replacements.
---   The returned valued is the transitive closure of implied
---   extensions.
-impliesExts :: [Extension] -> [Extension]
-impliesExts = go
-  where go [] = []
-        go es = let xs = concatMap implE es
-                    ys = filter (not . flip elem es) xs
-                 in es ++ go ys
-
-        implE e = case e of
-                    TypeFamilies        -> [KindSignatures]
-                    ScopedTypeVariables -> [TypeOperators, ExplicitForAll]
-                    XmlSyntax           -> [RegularPatterns]
-                    RegularPatterns     -> [PatternGuards]
-                    RankNTypes          -> [Rank2Types, ExplicitForAll]
-                    Rank2Types          -> [PolymorphicComponents, ExplicitForAll]
-                    PolymorphicComponents   -> [ExplicitForAll]
-                    LiberalTypeSynonyms -> [ExplicitForAll]
-                    ExistentialQuantification -> [ExplicitForAll]
-                    -- Deprecations
-                    RecordPuns          -> [NamedFieldPuns]
-                    PatternSignatures   -> [ScopedTypeVariables]
-                    e                   -> []
-
--- | The list of extensions enabled by
---   GHC's portmanteau -fglasgow-exts flag.
-glasgowExts :: [Extension]
-glasgowExts = [
-      ForeignFunctionInterface
-    , UnliftedFFITypes
-    , GADTs
-    , ImplicitParams
-    , ScopedTypeVariables
-    , UnboxedTuples
-    , TypeSynonymInstances
-    , StandaloneDeriving
-    , DeriveDataTypeable
-    , FlexibleContexts
-    , FlexibleInstances
-    , ConstrainedClassMethods
-    , MultiParamTypeClasses
-    , FunctionalDependencies
-    , MagicHash
-    , PolymorphicComponents
-    , ExistentialQuantification
-    , UnicodeSyntax
-    , PostfixOperators
-    , PatternGuards
-    , LiberalTypeSynonyms
-    , RankNTypes
-    , ImpredicativeTypes
-    , TypeOperators
-    , RecursiveDo
-    , ParallelListComp
-    , EmptyDataDecls
-    , KindSignatures
-    , GeneralizedNewtypeDeriving
-    , TypeFamilies
-    ]
-
-haskell98 :: [Extension]
-haskell98 = [NPlusKPatterns]
-
-haskell2010 :: [Extension]
-haskell2010 =
-    [ DoAndIfThenElse
-    , PatternGuards
-    , ForeignFunctionInterface
-    , EmptyDataDecls 
-    ]
-
--- | List of all known extensions. Poor man's 'Enum' instance
---   (we can't enum with the 'UnknownExtension' constructor).
-knownExtensions :: [Extension]
-knownExtensions = 
-    [ OverlappingInstances
-    , UndecidableInstances
-    , IncoherentInstances
-    , RecursiveDo
-    , ParallelListComp
-    , MultiParamTypeClasses
-    , NoMonomorphismRestriction
-    , FunctionalDependencies
-    , ExplicitForAll
-    , Rank2Types
-    , RankNTypes
-    , PolymorphicComponents
-    , ExistentialQuantification
-    , ScopedTypeVariables
-    , ImplicitParams
-    , FlexibleContexts
-    , FlexibleInstances
-    , EmptyDataDecls
-    , CPP
-    , KindSignatures
-    , BangPatterns
-    , TypeSynonymInstances
-    , TemplateHaskell
-    , ForeignFunctionInterface
-    , Arrows
-    , Generics
-    , NoImplicitPrelude
-    , NamedFieldPuns
-    , PatternGuards
-    , GeneralizedNewtypeDeriving
-    , ExtensibleRecords
-    , RestrictedTypeSynonyms
-    , HereDocuments
-    , MagicHash
-    , TypeFamilies
-    , StandaloneDeriving
-    , UnicodeSyntax
-    , PatternSignatures
-    , UnliftedFFITypes
-    , LiberalTypeSynonyms
-    , TypeOperators
-    , RecordWildCards
-    , RecordPuns -- should be deprecated
-    , DisambiguateRecordFields
-    , OverloadedStrings
-    , GADTs
-    , MonoPatBinds
-    , NoMonoPatBinds -- should be deprecated
-    , RelaxedPolyRec
-    , ExtendedDefaultRules
-    , UnboxedTuples
-    , DeriveDataTypeable
-    , ConstrainedClassMethods
-    , PackageImports
-    , ImpredicativeTypes
-    , NewQualifiedOperators
-    , PostfixOperators
-    , QuasiQuotes
-    , TransformListComp
-    , ViewPatterns
-    , XmlSyntax
-    , RegularPatterns
-    , TupleSections
-    , NPlusKPatterns
-    , DoAndIfThenElse
-    ]
-
-
-
--- | A clever version of read that returns an 'UnknownExtension'
---   if the string is not recognised.
-classifyExtension :: String -> Extension
-classifyExtension str
-  = case readsPrec 0 str of
-      [(e,"")]     -> e
-      _            -> UnknownExtension str
+-----------------------------------------------------------------------------+-- |+-- Module      :  Language.Haskell.Exts.Extension+-- Copyright   :  (c) Niklas Broberg 2009+-- License     :  BSD-style (see the file LICENSE.txt)+--+-- Maintainer  :  Niklas Broberg, niklas.broberg@chalmers.se+-- Stability   :  transient+-- Portability :  portable+--+-- This module defines the list of recognized modular features+-- of Haskell, most often (sloppily) referred to as "extensions".+--+-- Closely mimicking the Language.Haskell.Extension module from+-- the Cabal library, this package also includes functionality for+-- "computing" languages as sets of features. Also, we make no+-- promise not to add extensions not yet recognized by Cabal.+--+-----------------------------------------------------------------------------+module Language.Haskell.Exts.Extension (+    -- * Language definitions+    Language(..),+    knownLanguages,+    classifyLanguage,+    prettyLanguage,++    -- * Extensions+    Extension(..), KnownExtension(..),+    classifyExtension,+    parseExtension, prettyExtension,++    -- * Extension groups+    ghcDefault, glasgowExts, +    knownExtensions, deprecatedExtensions,++    -- * Semantics of extensions applied to languages+    impliesExts, toExtensionList++    ) where++import Control.Applicative ((<$>), (<|>))+import Data.Array (Array, accumArray, bounds, Ix(inRange), (!))+import Data.List (nub, (\\), delete)+import Data.Maybe (fromMaybe)++-- Copyright notice from Cabal's Language.Haskell.Extension,+-- from which we borrow plenty of features:++{- All rights reserved.++Redistribution and use in source and binary forms, with or without+modification, are permitted provided that the following conditions are+met:++    * Redistributions of source code must retain the above copyright+      notice, this list of conditions and the following disclaimer.++    * Redistributions in binary form must reproduce the above+      copyright notice, this list of conditions and the following+      disclaimer in the documentation and/or other materials provided+      with the distribution.++    * Neither the name of Isaac Jones nor the names of other+      contributors may be used to endorse or promote products derived+      from this software without specific prior written permission.++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -}++data Language =++  -- | The Haskell 98 language as defined by the Haskell 98 report.+  -- <http://haskell.org/onlinereport/>+     Haskell98++  -- | The Haskell 2010 language as defined by the Haskell 2010 report.+  -- <http://www.haskell.org/onlinereport/haskell2010>+  | Haskell2010++  -- | The minimal language resulting from disabling all recognized+  -- extensions - including ones that are part of all known language+  -- definitions e.g. MonomorphismRestriction.+  | HaskellAllDisabled++  -- | An unknown language, identified by its name.+  | UnknownLanguage String+  deriving (Show, Read, Eq, Ord)++knownLanguages :: [Language]+knownLanguages = [Haskell98, Haskell2010]++classifyLanguage :: String -> Language+classifyLanguage = \str -> case lookup str langTable of+    Just lang -> lang+    Nothing   -> UnknownLanguage str+  where+    langTable = [ (show lang, lang)+                | lang <- knownLanguages ]++prettyLanguage :: Language -> String+prettyLanguage (UnknownLanguage name) = name+prettyLanguage lang = show lang++-- | This represents language extensions beyond a base 'Language' definition+-- (such as 'Haskell98') that are supported by some implementations, usually+-- in some special mode.++data Extension =+  -- | Enable a known extension+    EnableExtension KnownExtension++  -- | Disable a known extension+  | DisableExtension KnownExtension++  -- | An unknown extension, identified by the name of its @LANGUAGE@+  -- pragma.+  | UnknownExtension String+  deriving (Show, Read, Eq, Ord)+++data KnownExtension =++  -- | [GHC &#xa7; 7.6.3.4] Allow overlapping class instances,+  -- provided there is a unique most specific instance for each use.+    OverlappingInstances++  -- | [GHC &#xa7; 7.6.3.3] Ignore structural rules guaranteeing the+  -- termination of class instance resolution.  Termination is+  -- guaranteed by a fixed-depth recursion stack, and compilation+  -- may fail if this depth is exceeded.+  | UndecidableInstances++  -- | [GHC &#xa7; 7.6.3.4] Implies 'OverlappingInstances'.  Allow the+  -- implementation to choose an instance even when it is possible+  -- that further instantiation of types will lead to a more specific+  -- instance being applicable.+  | IncoherentInstances++{- DoRec not yet supported by HSE.++  -- | [GHC &#xa7; 7.3.8] Allows recursive bindings in @do@ blocks,+  -- using the @rec@ keyword.+  | DoRec++-}++  -- | [GHC &#xa7; 7.3.8.2] Deprecated in GHC.  Allows recursive bindings+  -- using @mdo@, a variant of @do@.  @DoRec@ provides a different,+  -- preferred syntax.+  | RecursiveDo++  -- | [GHC &#xa7; 7.3.9] Provide syntax for writing list+  -- comprehensions which iterate over several lists together, like+  -- the 'zipWith' family of functions.+  | ParallelListComp++  -- | [GHC &#xa7; 7.6.1.1] Allow multiple parameters in a type class.+  | MultiParamTypeClasses++  -- | [GHC &#xa7; 7.17] Enable the dreaded monomorphism restriction.+  | MonomorphismRestriction++  -- | [GHC &#xa7; 7.6.2] Allow a specification attached to a+  -- multi-parameter type class which indicates that some parameters+  -- are entirely determined by others. The implementation will check+  -- that this property holds for the declared instances, and will use+  -- this property to reduce ambiguity in instance resolution.+  | FunctionalDependencies++  -- | [GHC &#xa7; 7.8.5] Like 'RankNTypes' but does not allow a+  -- higher-rank type to itself appear on the left of a function+  -- arrow.+  | Rank2Types++  -- | [GHC &#xa7; 7.8.5] Allow a universally-quantified type to occur on+  -- the left of a function arrow.+  | RankNTypes++  -- | [GHC &#xa7; 7.8.5] Allow data constructors to have polymorphic+  -- arguments.  Unlike 'RankNTypes', does not allow this for ordinary+  -- functions.+  | PolymorphicComponents++  -- | [GHC &#xa7; 7.4.4] Allow existentially-quantified data constructors.+  | ExistentialQuantification++  -- | [GHC &#xa7; 7.8.7] Cause a type variable in a signature, which has an+  -- explicit @forall@ quantifier, to scope over the definition of the+  -- accompanying value declaration.+  | ScopedTypeVariables++  -- | Deprecated, use 'ScopedTypeVariables' instead.+  | PatternSignatures++  -- | [GHC &#xa7; 7.8.3] Enable implicit function parameters with dynamic+  -- scope.+  | ImplicitParams++  -- | [GHC &#xa7; 7.8.2] Relax some restrictions on the form of the context+  -- of a type signature.+  | FlexibleContexts++  -- | [GHC &#xa7; 7.6.3.2] Relax some restrictions on the form of the+  -- context of an instance declaration.+  | FlexibleInstances++  -- | [GHC &#xa7; 7.4.1] Allow data type declarations with no constructors.+  | EmptyDataDecls++  -- | [GHC &#xa7; 4.10.3] Run the C preprocessor on Haskell source code.+  | CPP++  -- | [GHC &#xa7; 7.8.4] Allow an explicit kind signature giving the kind of+  -- types over which a type variable ranges.+  | KindSignatures++  -- | [GHC &#xa7; 7.11] Enable a form of pattern which forces evaluation+  -- before an attempted match, and a form of strict @let@/@where@+  -- binding.+  | BangPatterns++  -- | [GHC &#xa7; 7.6.3.1] Allow type synonyms in instance heads.+  | TypeSynonymInstances++  -- | [GHC &#xa7; 7.9] Enable Template Haskell, a system for compile-time+  -- metaprogramming.+  | TemplateHaskell++  -- | [GHC &#xa7; 8] Enable the Foreign Function Interface.  In GHC,+  -- implements the standard Haskell 98 Foreign Function Interface+  -- Addendum, plus some GHC-specific extensions.+  | ForeignFunctionInterface++  -- | [GHC &#xa7; 7.10] Enable arrow notation.+  | Arrows++  -- | [GHC &#xa7; 7.16] Enable generic type classes, with default instances+  -- defined in terms of the algebraic structure of a type.+  | Generics++  -- | [GHC &#xa7; 7.3.11] Enable the implicit importing of the module+  -- @Prelude@.  When disabled, when desugaring certain built-in syntax+  -- into ordinary identifiers, use whatever is in scope rather than the+  -- @Prelude@ -- version.+  | ImplicitPrelude++  -- | [GHC &#xa7; 7.3.15] Enable syntax for implicitly binding local names+  -- corresponding to the field names of a record.  Puns bind specific+  -- names, unlike 'RecordWildCards'.+  | NamedFieldPuns++  -- | [GHC &#xa7; 7.3.5] Enable a form of guard which matches a pattern and+  -- binds variables.+  | PatternGuards++  -- | [GHC &#xa7; 7.5.4] Allow a type declared with @newtype@ to use+  -- @deriving@ for any class with an instance for the underlying type.+  | GeneralizedNewtypeDeriving++  -- | [Hugs &#xa7; 7.1] Enable the \"Trex\" extensible records system.+  | ExtensibleRecords++  -- | [Hugs &#xa7; 7.2] Enable type synonyms which are transparent in+  -- some definitions and opaque elsewhere, as a way of implementing +  -- abstract datatypes.+  | RestrictedTypeSynonyms++  -- | [Hugs &#xa7; 7.3] Enable an alternate syntax for string literals,+  -- with string templating.+  | HereDocuments++  -- | [GHC &#xa7; 7.3.2] Allow the character @#@ as a postfix modifier on+  -- identifiers.  Also enables literal syntax for unboxed values.+  | MagicHash++  -- | [GHC &#xa7; 7.7] Allow data types and type synonyms which are+  -- indexed by types, i.e. ad-hoc polymorphism for types.+  | TypeFamilies++  -- | [GHC &#xa7; 7.5.2] Allow a standalone declaration which invokes the+  -- type class @deriving@ mechanism.+  | StandaloneDeriving++  -- | [GHC &#xa7; 7.3.1] Allow certain Unicode characters to stand for+  -- certain ASCII character sequences, e.g. keywords and punctuation.+  | UnicodeSyntax++  -- | [GHC &#xa7; 8.1.1] Allow the use of unboxed types as foreign types,+  -- e.g. in @foreign import@ and @foreign export@.+  | UnliftedFFITypes++  -- | [GHC &#xa7; 7.4.3] Defer validity checking of types until after+  -- expanding type synonyms, relaxing the constraints on how synonyms+  -- may be used.+  | LiberalTypeSynonyms++  -- | [GHC &#xa7; 7.4.2] Allow the name of a type constructor, type class,+  -- or type variable to be an infix operator.+  | TypeOperators++--PArr -- not ready yet, and will probably be renamed to ParallelArrays++  -- | [GHC &#xa7; 7.3.16] Enable syntax for implicitly binding local names+  -- corresponding to the field names of a record.  A wildcard binds+  -- all unmentioned names, unlike 'NamedFieldPuns'.+  | RecordWildCards++  -- | Deprecated, use 'NamedFieldPuns' instead.+  | RecordPuns++  -- | [GHC &#xa7; 7.3.14] Allow a record field name to be disambiguated+  -- by the type of the record it's in.+  | DisambiguateRecordFields++  -- | [GHC &#xa7; 7.6.4] Enable overloading of string literals using a+  -- type class, much like integer literals.+  | OverloadedStrings++  -- | [GHC &#xa7; 7.4.6] Enable generalized algebraic data types, in+  -- which type variables may be instantiated on a per-constructor+  -- basis. Implies GADTSyntax.+  | GADTs++{- GADTSyntax (the extension name) not yet supported by HSE++  -- | Enable GADT syntax for declaring ordinary algebraic datatypes.+  | GADTSyntax++-}++  -- | [GHC &#xa7; 7.17.2] Make pattern bindings monomorphic.+  | MonoPatBinds++  -- | [GHC &#xa7; 7.8.8] Relax the requirements on mutually-recursive+  -- polymorphic functions.+  | RelaxedPolyRec++  -- | [GHC &#xa7; 2.4.5] Allow default instantiation of polymorphic+  -- types in more situations.+  | ExtendedDefaultRules++  -- | [GHC &#xa7; 7.2.2] Enable unboxed tuples.+  | UnboxedTuples++  -- | [GHC &#xa7; 7.5.3] Enable @deriving@ for classes+  -- @Data.Typeable.Typeable@ and @Data.Generics.Data@.+  | DeriveDataTypeable++  -- | [GHC &#xa7; 7.6.1.3] Allow a class method's type to place+  -- additional constraints on a class type variable.+  | ConstrainedClassMethods++  -- | [GHC &#xa7; 7.3.18] Allow imports to be qualified by the package+  -- name the module is intended to be imported from, e.g.+  --+  -- > import "network" Network.Socket+  | PackageImports++  -- | [GHC &#xa7; 7.8.6] Deprecated in GHC 6.12 and will be removed in+  -- GHC 7.  Allow a type variable to be instantiated at a+  -- polymorphic type.+  | ImpredicativeTypes++  -- | [GHC &#xa7; 7.3.3] Change the syntax for qualified infix+  -- operators.+  | NewQualifiedOperators++  -- | [GHC &#xa7; 7.3.12] Relax the interpretation of left operator+  -- sections to allow unary postfix operators.+  | PostfixOperators++  -- | [GHC &#xa7; 7.9.5] Enable quasi-quotation, a mechanism for defining+  -- new concrete syntax for expressions and patterns.+  | QuasiQuotes++  -- | [GHC &#xa7; 7.3.10] Enable generalized list comprehensions,+  -- supporting operations such as sorting and grouping.+  | TransformListComp++  -- | [GHC &#xa7; 7.3.6] Enable view patterns, which match a value by+  -- applying a function and matching on the result.+  | ViewPatterns++  -- | Allow concrete XML syntax to be used in expressions and patterns,+  -- as per the Haskell Server Pages extension language:+  -- <http://www.haskell.org/haskellwiki/HSP>. The ideas behind it are+  -- discussed in the paper \"Haskell Server Pages through Dynamic Loading\"+  -- by Niklas Broberg, from Haskell Workshop '05.+  | XmlSyntax++  -- | Allow regular pattern matching over lists, as discussed in the+  -- paper \"Regular Expression Patterns\" by Niklas Broberg, Andreas Farre+  -- and Josef Svenningsson, from ICFP '04.+  | RegularPatterns++  -- | Enables the use of tuple sections, e.g. @(, True)@ desugars into+  -- @\x -> (x, True)@.+  | TupleSections++  -- | Allows GHC primops, written in C--, to be imported into a Haskell+  -- file.+  | GHCForeignImportPrim++  -- | Support for patterns of the form @n + k@, where @k@ is an+  -- integer literal.+  | NPlusKPatterns++  -- | Improve the layout rule when @if@ expressions are used in a @do@+  -- block.+  | DoAndIfThenElse++  -- | Makes much of the Haskell sugar be desugared into calls to the+  -- function with a particular name that is in scope.+  | RebindableSyntax++  -- | Make @forall@ a keyword in types, which can be used to give the+  -- generalisation explicitly.+  | ExplicitForAll++  -- | Allow contexts to be put on datatypes, e.g. the @Eq a@ in+  -- @data Eq a => Set a = NilSet | ConsSet a (Set a)@.+  | DatatypeContexts++  -- | Local (@let@ and @where@) bindings are monomorphic.+  | MonoLocalBinds++  -- | Enable @deriving@ for the @Data.Functor.Functor@ class.+  | DeriveFunctor++  -- | Enable @deriving@ for the @Data.Traversable.Traversable@ class.+  | DeriveTraversable++  -- | Enable @deriving@ for the @Data.Foldable.Foldable@ class.+  | DeriveFoldable++  -- | Enable non-decreasing indentation for 'do' blocks.+  | NondecreasingIndentation++  -- | [GHC &#xa7; 8.1.4] Enable interruptible FFI.+  | InterruptibleFFI++  -- | [GHC &#xa7; 8.1.5] Enable the 'capi' calling convention in the+  -- foreign function interface.+  | CApiFFI++ {- Safe Haskell not yet supported by HSE.++  -- | [GHC &#xa7; 7.20.3] Allow imports to be qualified with a safe+  -- keyword that requires the imported module be trusted as according+  -- to the Safe Haskell definition of trust.+  --+  -- > import safe Network.Socket+  | SafeImports++  -- | [GHC &#xa7; 7.20] Compile a module in the Safe, Safe Haskell+  -- mode -- a restricted form of the Haskell language to ensure+  -- type safety.+  | Safe++  -- | [GHC &#xa7; 7.20] Compile a module in the Trustworthy, Safe+  -- Haskell mode -- no restrictions apply but the module is marked+  -- as trusted as long as the package the module resides in is+  -- trusted.+  | Trustworthy++-}++{- ConstraintKinds not yet supported by HSE++  -- | [GHC &#xa7; 7.40] Allow type class/implicit parameter/equality+  -- constraints to be used as types with the special kind Constraint.+  -- Also generalise the (ctxt => ty) syntax so that any type of kind+  -- Constraint can occur before the arrow.+  | ConstraintKinds++-}++  deriving (Show, Read, Eq, Ord, Enum, Bounded)++-- | Certain extensions imply other extensions, and this function+--   makes the implication explicit. This also handles deprecated+--   extensions, which imply their replacements.+--   The returned value is the transitive closure of implied+--   extensions.+{-impliesExts :: [Extension] -> [Extension]+impliesExts exts = +    let posExts = [ ke | EnableExtension  ke <- exts ]+        negExts = [ ke | DisableExtension ke <- exts ]++        implExts = impliesKnownExts posExts+     in +-}+impliesExts :: [KnownExtension] -> [KnownExtension]+impliesExts = go+  where go [] = []+        go es = let xs = concatMap implE es+                    ys = filter (not . flip elem es) xs+                 in es ++ go ys++        implE e = case e of+                    TypeFamilies        -> [KindSignatures]+                    ScopedTypeVariables -> [TypeOperators, ExplicitForAll]+                    XmlSyntax           -> [RegularPatterns]+                    RegularPatterns     -> [PatternGuards]+                    RankNTypes          -> [Rank2Types, ExplicitForAll]+                    Rank2Types          -> [PolymorphicComponents, ExplicitForAll]+                    PolymorphicComponents   -> [ExplicitForAll]+                    LiberalTypeSynonyms -> [ExplicitForAll]+                    ExistentialQuantification -> [ExplicitForAll]+                    -- Deprecations+                    RecordPuns          -> [NamedFieldPuns]+                    PatternSignatures   -> [ScopedTypeVariables]+                    e                   -> []++-- | The list of extensions enabled by+--   GHC's portmanteau -fglasgow-exts flag.+glasgowExts :: [Extension]+glasgowExts = map EnableExtension [+      ForeignFunctionInterface+    , UnliftedFFITypes+    , GADTs+    , ImplicitParams+    , ScopedTypeVariables+    , UnboxedTuples+    , TypeSynonymInstances+    , StandaloneDeriving+    , DeriveDataTypeable+    , FlexibleContexts+    , FlexibleInstances+    , ConstrainedClassMethods+    , MultiParamTypeClasses+    , FunctionalDependencies+    , MagicHash+    , PolymorphicComponents+    , ExistentialQuantification+    , UnicodeSyntax+    , PostfixOperators+    , PatternGuards+    , LiberalTypeSynonyms+    , RankNTypes+    , ImpredicativeTypes+    , TypeOperators+    , RecursiveDo+    , ParallelListComp+    , EmptyDataDecls+    , KindSignatures+    , GeneralizedNewtypeDeriving+    , TypeFamilies+    ]++-- Not exported, just used locally in several places.+allLangDefault :: [KnownExtension]+allLangDefault = [MonomorphismRestriction, MonoPatBinds, ImplicitPrelude]++ghcDefault :: [Extension]+ghcDefault = map EnableExtension (NondecreasingIndentation:allLangDefault)++-- | List of all known extensions, all enabled.+knownExtensions :: [Extension]+knownExtensions =+  concat [ [EnableExtension x, DisableExtension x] | x <- [minBound..maxBound] ]++-- | Extensions that have been deprecated, possibly paired with another+-- extension that replaces it.+--+deprecatedExtensions :: [(Extension, Maybe Extension)]+deprecatedExtensions =+  [ (EnableExtension RecordPuns, Just (EnableExtension NamedFieldPuns))+  , (EnableExtension PatternSignatures, Just (EnableExtension ScopedTypeVariables))+  ]++++-- | A clever version of read that returns an 'UnknownExtension'+--   if the string is not recognised.+classifyExtension :: String -> Extension+classifyExtension string+  = case classifyKnownExtension string of+    Just ext -> EnableExtension ext+    Nothing ->+        case string of+        'N':'o':string' ->+            case classifyKnownExtension string' of+            Just ext -> DisableExtension ext+            Nothing -> UnknownExtension string+        _ -> UnknownExtension string+++classifyKnownExtension :: String -> Maybe KnownExtension+classifyKnownExtension "" = Nothing+classifyKnownExtension string@(c : _)+  | inRange (bounds knownExtensionTable) c+  = lookup string (knownExtensionTable ! c)+  | otherwise = Nothing++knownExtensionTable :: Array Char [(String, KnownExtension)]+knownExtensionTable =+  accumArray (flip (:)) [] ('A', 'Z')+    [ (head str, (str, extension))+    | extension <- [toEnum 0 ..]+    , let str = show extension ]++-- | Parse an enabled or disabled extension; returns+-- 'UnknownExtension' if the parse fails.+parseExtension :: String -> Extension+parseExtension str = fromMaybe (UnknownExtension str) $+      EnableExtension  <$> readMay str+  <|> DisableExtension <$> (readMay =<< dropNo str)+  where+    dropNo ('N':'o':rest) = Just rest+    dropNo _              = Nothing++-- | Pretty print an extension. Disabled extensions are prefixed with+-- \'No\'.+prettyExtension :: Extension -> String+prettyExtension (EnableExtension  ext) = show ext+prettyExtension (DisableExtension ext) = "No" ++ show ext+prettyExtension (UnknownExtension str) = str++readMay :: Read a => String -> Maybe a+readMay s = case [x | (x,t) <- reads s, ("","") <- lex t] of+                [x] -> Just x+                _ -> Nothing++{-------------------------------------------+ -- Transform a 'Language', and possibly a modifying set of'Extension's, into a list + -- of 'KnownExtension's, to be interpreted as modifying the language you get + -- when all known extensions are disabled.+ -- Extensions are interpreted in a right-biased fashion, so the last instance+ -- of an occurence of 'EnableExtension' or 'DisableExtension' for a given+ -- 'KnownExtension' takes precedence.+ -------------------------------------------}++toExtensionList :: Language -> [Extension] -> [KnownExtension]+toExtensionList lang exts =+    let langKes = case lang of+                    Haskell98 -> NPlusKPatterns:allLangDefault+                    Haskell2010 -> [DoAndIfThenElse+                                   , PatternGuards+                                   , ForeignFunctionInterface+                                   , EmptyDataDecls +                                   ] ++ allLangDefault+                    HaskellAllDisabled -> []+                    UnknownLanguage s -> +                        error $ "toExtensionList: Unknown language " ++ s+{-+        addExts = [ ke | EnableExtension  ke <- exts ]+        remExts = [ ke | DisableExtension ke <- exts ]+     in impliesExts $ nub $ (langKes ++ addExts) \\ remExts+-}+  in impliesExts $ go langKes exts+    where go :: [KnownExtension] -> [Extension] -> [KnownExtension]+          go acc [] = acc+          go acc (DisableExtension x : exts) = go (nub (delete x acc)) exts+          go acc (EnableExtension  x : exts) = go (nub (x : acc))      exts+          -- We just throw away UnknownExtensions+          go acc (_ : exts) = go acc exts+
src/Language/Haskell/Exts/Fixity.hs view
@@ -1,402 +1,403 @@-{-# LANGUAGE CPP, DeriveDataTypeable #-}
------------------------------------------------------------------------------
--- |
--- Module      :  Language.Haskell.Exts.Fixity
--- Copyright   :  (c) Niklas Broberg 2009
--- License     :  BSD-style (see the file LICENSE.txt)
---
--- Maintainer  :  Niklas Broberg, d00nibro@chalmers.se
--- Stability   :  stable
--- Portability :  portable
---
--- Fixity information to give the parser so that infix operators can
--- be parsed properly.
---
------------------------------------------------------------------------------
-module Language.Haskell.Exts.Fixity
-    (
-    -- * Fixity representation
-      Fixity(..)
-    -- | The following three functions all create lists of
-    --   fixities from textual representations of operators.
-    --   The intended usage is e.g.
-    --
-    -- > fixs = infixr_ 0  ["$","$!","`seq`"]
-    --
-    --   Note that the operators are expected as you would
-    --   write them infix, i.e. with ` characters surrounding
-    --   /varid/ operators, and /varsym/ operators written as is.
-    , infix_, infixl_, infixr_
-    -- ** Collections of fixities
-    , preludeFixities, baseFixities, prefixMinusFixity
-
-    -- * Applying fixities to an AST
-    , AppFixity(..)
-    ) where
-
-import Language.Haskell.Exts.Syntax
-
-import Data.Char (isUpper)
-import Control.Monad (when, (<=<), liftM, liftM2, liftM3, liftM4)
-import Data.Traversable (mapM)
-import Prelude hiding (mapM)
-
-#ifdef __GLASGOW_HASKELL__
-#ifdef BASE4
-import Data.Data hiding (Fixity)
-#else
-import Data.Generics (Data(..),Typeable(..))
-#endif
-#endif
-
--- | Operator fixities are represented by their associativity
---   (left, right or none) and their precedence (0-9).
-data Fixity = Fixity Assoc Int QName
-#ifdef __GLASGOW_HASKELL__
-  deriving (Eq,Ord,Show,Typeable,Data)
-#else
-  deriving (Eq,Ord,Show)
-#endif
-
--- | All AST elements that may include expressions which in turn may
---   need fixity tweaking will be instances of this class.
-class AppFixity ast where
-  -- | Tweak any expressions in the element to account for the
-  --   fixities given. Assumes that all operator expressions are
-  --   fully left associative chains to begin with.
-  applyFixities :: Monad m => [Fixity] -- ^ The fixities to account for.
-                    -> ast  -- ^ The element to tweak.
-                    -> m ast  -- ^ The same element, but with operator expressions updated, or a failure.
-
-
-instance AppFixity Exp where
-  applyFixities fixs = infFix fixs <=< leafFix fixs
-    where -- This is the real meat case. We can assume a left-associative list to begin with.
-          infFix fixs (InfixApp a op2 z) = do
-              e <- infFix fixs a
-              let fixup (a1,p1) (a2,p2) y pre = do
-                      when (p1 == p2 && (a1 /= a2 || a1 == AssocNone)) -- Ambiguous infix expression!
-                           $ fail "Ambiguous infix expression"
-                      if (p1 > p2 || p1 == p2 && (a1 == AssocLeft || a2 == AssocNone)) -- Already right order
-                       then return $ InfixApp e op2 z
-                       else liftM pre (infFix fixs $ InfixApp y op2 z)
-              case e of
-               InfixApp x op1 y -> fixup (askFixity fixs op1) (askFixity fixs op2) y (InfixApp x op1)
-               NegApp         y -> fixup prefixMinusFixity    (askFixity fixs op2) y  NegApp
-               _  -> return $ InfixApp e op2 z
-
-          infFix _ e = return e
-
-instance AppFixity Pat where
-  applyFixities fixs = infFix fixs <=< leafFixP fixs
-    where -- Same for patterns
-          infFix fixs (PInfixApp a op2 z) = do
-              p <- infFix fixs a
-              let fixup (a1,p1) (a2,p2) y pre = do
-                      when (p1 == p2 && (a1 /= a2 || a1 == AssocNone )) -- Ambiguous infix expression!
-                           $ fail "Ambiguous infix expression"
-                      if (p1 > p2 || p1 == p2 && (a1 == AssocLeft || a2 == AssocNone)) -- Already right order
-                       then return $ PInfixApp p op2 z
-                       else liftM pre (infFix fixs $ PInfixApp y op2 z)
-              case p of
-               PInfixApp x op1 y -> fixup (askFixityP fixs op1) (askFixityP fixs op2) y (PInfixApp x op1)
-               PNeg            y -> fixup prefixMinusFixity     (askFixityP fixs op2) y  PNeg
-               _  -> return $ PInfixApp p op2 z
-
-          infFix _ p = return p
-
-
--- Internal: lookup associativity and precedence of an operator
-askFixity :: [Fixity] -> QOp -> (Assoc, Int)
-askFixity xs k = askFix xs (f k) -- undefined -- \k -> askFixityP xs (f k) -- lookupWithDefault (AssocLeft, 9) (f k) mp
-    where
-        f (QVarOp x) = g x
-        f (QConOp x) = g x
-
-        g (Special Cons) = UnQual (Symbol ":")
-        g x              = x
-
--- Same using patterns
-askFixityP :: [Fixity] -> QName -> (Assoc, Int)
-askFixityP xs qn = askFix xs (g qn)
-    where
-        g (Special Cons) = UnQual (Symbol ":")
-        g x              = x
-        
-askFix :: [Fixity] -> QName -> (Assoc, Int)
-askFix xs = \k -> lookupWithDefault (AssocLeft, 9) k mp
-    where
-        lookupWithDefault def k mp = case lookup k mp of
-            Nothing -> def
-            Just x  -> x
-
-        mp = [(x,(a,p)) | Fixity a p x <- xs]
-
-
--- | Built-in fixity for prefix minus
-prefixMinusFixity :: (Assoc, Int)
-prefixMinusFixity = (AssocLeft, 6)
-
--- | All fixities defined in the Prelude.
-preludeFixities :: [Fixity]
-preludeFixities = concat
-    [infixr_ 9  ["."]
-    ,infixl_ 9  ["!!"]
-    ,infixr_ 8  ["^","^^","**"]
-    ,infixl_ 7  ["*","/","`quot`","`rem`","`div`","`mod`",":%","%"]
-    ,infixl_ 6  ["+","-"]
-    ,infixr_ 5  [":","++"]
-    ,infix_  4  ["==","/=","<","<=",">=",">","`elem`","`notElem`"]
-    ,infixr_ 3  ["&&"]
-    ,infixr_ 2  ["||"]
-    ,infixl_ 1  [">>",">>="]
-    ,infixr_ 1  ["=<<"]
-    ,infixr_ 0  ["$","$!","`seq`"]
-    ]
-
--- | All fixities defined in the base package.
---
---   Note that the @+++@ operator appears in both Control.Arrows and
---   Text.ParserCombinators.ReadP. The listed precedence for @+++@ in
---   this list is that of Control.Arrows.
-baseFixities :: [Fixity]
-baseFixities = preludeFixities ++ concat
-    [infixl_ 9 ["!","//","!:"]
-    ,infixl_ 8 ["`shift`","`rotate`","`shiftL`","`shiftR`","`rotateL`","`rotateR`"]
-    ,infixl_ 7 [".&."]
-    ,infixl_ 6 ["`xor`"]
-    ,infix_  6 [":+"]
-    ,infixl_ 5 [".|."]
-    ,infixr_ 5 ["+:+","<++","<+>"] -- fixity conflict for +++ between ReadP and Arrow
-    ,infix_  5 ["\\\\"]
-    ,infixl_ 4 ["<$>","<$","<*>","<*","*>","<**>"]
-    ,infix_  4 ["`elemP`","`notElemP`"]
-    ,infixl_ 3 ["<|>"]
-    ,infixr_ 3 ["&&&","***"]
-    ,infixr_ 2 ["+++","|||"]
-    ,infixr_ 1 ["<=<",">=>",">>>","<<<","^<<","<<^","^>>",">>^"]
-    ,infixl_ 0 ["`on`"]
-    ,infixr_ 0 ["`par`","`pseq`"]
-    ]
-
-infixr_, infixl_, infix_ :: Int -> [String] -> [Fixity]
-infixr_ = fixity AssocRight
-infixl_ = fixity AssocLeft
-infix_  = fixity AssocNone
-
--- Internal: help function for the above definitions.
-fixity :: Assoc -> Int -> [String] -> [Fixity]
-fixity a p = map (Fixity a p . op)
-    where
-        op ('`':xs) = UnQual $ Ident $ init xs
-        op xs = UnQual $ Symbol xs
-
-
-
-
-
-
--------------------------------------------------------------------
--- Boilerplate - yuck!! Everything below here is internal stuff
-
-instance AppFixity Module where
-    applyFixities fixs (Module loc n prs mwt ext imp decls) =
-        liftM (Module loc n prs mwt ext imp) $ appFixDecls fixs decls
-
-instance AppFixity Decl where
-    applyFixities fixs decl = case decl of
-        ClassDecl loc ctxt n vars deps cdecls   -> liftM (ClassDecl loc ctxt n vars deps) $ mapM fix cdecls
-        InstDecl loc ctxt n ts idecls           -> liftM (InstDecl loc ctxt n ts) $ mapM fix idecls
-        SpliceDecl loc spl      -> liftM (SpliceDecl loc) $ fix spl
-        FunBind matches         -> liftM FunBind $ mapM fix matches
-        PatBind loc p mt rhs bs -> liftM3 (flip (PatBind loc) mt) (fix p) (fix rhs) (fix bs)
-        AnnPragma loc ann       -> liftM (AnnPragma loc) $ fix ann
-        _                       -> return decl
-      where fix x = applyFixities fixs x
-
-appFixDecls :: Monad m => [Fixity] -> [Decl] -> m [Decl]
-appFixDecls fixs decls =
-    let extraFixs = getFixities decls
-     in mapM (applyFixities (fixs++extraFixs)) decls
-  where getFixities = concatMap getFixity
-        getFixity (InfixDecl _ a p ops) = map (Fixity a p . g) ops
-        getFixity _ = []
-        g (VarOp x) = UnQual x
-        g (ConOp x) = UnQual x
-
-instance AppFixity Annotation where
-    applyFixities fixs ann = case ann of
-        Ann     n e   -> liftM (Ann n) $ fix e
-        TypeAnn n e   -> liftM (TypeAnn n) $ fix e
-        ModuleAnn e   -> liftM ModuleAnn $ fix e
-      where fix x = applyFixities fixs x
-
-instance AppFixity ClassDecl where
-    applyFixities fixs (ClsDecl decl) = liftM ClsDecl $ applyFixities fixs decl
-    applyFixities _ cdecl = return cdecl
-
-instance AppFixity InstDecl where
-    applyFixities fixs (InsDecl decl) = liftM InsDecl $ applyFixities fixs decl
-    applyFixities _ idecl = return idecl
-
-instance AppFixity Match where
-    applyFixities fixs (Match loc n ps mt rhs bs) = liftM3 (flip (Match loc n) mt) (mapM fix ps) (fix rhs) (fix bs)
-      where fix x = applyFixities fixs x
-
-instance AppFixity Rhs where
-    applyFixities fixs rhs = case rhs of
-        UnGuardedRhs e      -> liftM UnGuardedRhs $ fix e
-        GuardedRhss grhss   -> liftM GuardedRhss $ mapM fix grhss
-      where fix x = applyFixities fixs x
-
-instance AppFixity GuardedRhs where
-    applyFixities fixs (GuardedRhs loc stmts e) = liftM2 (GuardedRhs loc) (mapM fix stmts) $ fix e
-      where fix x = applyFixities fixs x
-
-instance AppFixity PatField where
-    applyFixities fixs (PFieldPat n p) = liftM (PFieldPat n) $ applyFixities fixs p
-    applyFixities _ pf = return pf
-
-instance AppFixity RPat where
-    applyFixities fixs rp = case rp of
-        RPOp rp op          -> liftM (flip RPOp op) (fix rp)
-        RPEither a b        -> liftM2 RPEither (fix a) (fix b)
-        RPSeq rps           -> liftM RPSeq $ mapM fix rps
-        RPGuard p stmts     -> liftM2 RPGuard (fix p) $ mapM fix stmts
-        RPCAs n rp          -> liftM (RPCAs n) $ fix rp
-        RPAs n rp           -> liftM (RPAs n) $ fix rp
-        RPParen rp          -> liftM RPParen $ fix rp
-        RPPat p             -> liftM RPPat $ fix p
-      where fix x = applyFixities fixs x
-
-instance AppFixity PXAttr where
-    applyFixities fixs (PXAttr n p) = liftM (PXAttr n) $ applyFixities fixs p
-
-instance AppFixity Stmt where
-    applyFixities fixs stmt = case stmt of
-        Generator loc p e   -> liftM2 (Generator loc) (fix p) (fix e)
-        Qualifier e         -> liftM Qualifier $ fix e
-        LetStmt bs          -> liftM LetStmt $ fix bs    -- special behavior
-        RecStmt stmts       -> liftM RecStmt $ mapM fix stmts
-      where fix x = applyFixities fixs x
-
-instance AppFixity Binds where
-    applyFixities fixs bs = case bs of
-        BDecls decls        -> liftM BDecls $ appFixDecls fixs decls  -- special behavior
-        IPBinds ips         -> liftM IPBinds $ mapM fix ips
-      where fix x = applyFixities fixs x
-
-
-instance AppFixity IPBind where
-    applyFixities fixs (IPBind loc n e) = liftM (IPBind loc n) $ applyFixities fixs e
-
-instance AppFixity FieldUpdate where
-    applyFixities fixs (FieldUpdate n e) = liftM (FieldUpdate n) $ applyFixities fixs e
-    applyFixities _ fup = return fup
-
-instance AppFixity Alt where
-    applyFixities fixs (Alt loc p galts bs) = liftM3 (Alt loc) (fix p) (fix galts) (fix bs)
-      where fix x = applyFixities fixs x
-
-instance AppFixity GuardedAlts where
-    applyFixities fixs galts = case galts of
-        UnGuardedAlt e      -> liftM UnGuardedAlt $ fix e
-        GuardedAlts  galts  -> liftM GuardedAlts $ mapM fix galts
-      where fix x = applyFixities fixs x
-
-instance AppFixity GuardedAlt where
-    applyFixities fixs (GuardedAlt loc stmts e) = liftM2 (GuardedAlt loc) (mapM fix stmts) (fix e)
-      where fix x = applyFixities fixs x
-
-instance AppFixity QualStmt where
-    applyFixities fixs qstmt = case qstmt of
-        QualStmt     s      -> liftM QualStmt $ fix s
-        ThenTrans    e      -> liftM ThenTrans $ fix e
-        ThenBy       e1 e2  -> liftM2 ThenBy (fix e1) (fix e2)
-        GroupBy      e      -> liftM GroupBy (fix e)
-        GroupUsing   e      -> liftM GroupUsing (fix e)
-        GroupByUsing e1 e2  -> liftM2 GroupByUsing (fix e1) (fix e2)
-      where fix x = applyFixities fixs x
-
-instance AppFixity Bracket where
-    applyFixities fixs br = case br of
-        ExpBracket e    -> liftM ExpBracket $ fix e
-        PatBracket p    -> liftM PatBracket $ fix p
-        DeclBracket ds  -> liftM DeclBracket $ mapM fix ds
-        _               -> return br
-      where fix x = applyFixities fixs x
-
-instance AppFixity Splice where
-    applyFixities fixs (ParenSplice e) = liftM ParenSplice $ applyFixities fixs e
-    applyFixities _ s = return s
-
-instance AppFixity XAttr where
-    applyFixities fixs (XAttr n e) = liftM (XAttr n) $ applyFixities fixs e
-
-
--- the boring boilerplate stuff for expressions too
--- Recursively fixes the "leaves" of the infix chains,
--- without yet touching the chain itself. We assume all chains are
--- left-associate to begin with.
-leafFix fixs e = case e of
-    InfixApp e1 op e2       -> liftM2 (flip InfixApp op) (leafFix fixs e1) (fix e2)
-    App e1 e2               -> liftM2 App (fix e1) (fix e2)
-    NegApp e                -> liftM NegApp $ fix e
-    Lambda loc pats e       -> liftM2 (Lambda loc) (mapM fix pats) $ fix e
-    Let bs e                -> liftM2 Let (fix bs) $ fix e
-    If e a b                -> liftM3 If (fix e) (fix a) (fix b)
-    Case e alts             -> liftM2 Case (fix e) $ mapM fix alts
-    Do stmts                -> liftM Do $ mapM fix stmts
-    MDo stmts               -> liftM MDo $ mapM fix stmts
-    Tuple exps              -> liftM Tuple $ mapM fix exps
-    List exps               -> liftM List $ mapM fix  exps
-    Paren e                 -> liftM Paren $ fix e
-    LeftSection e op        -> liftM (flip LeftSection op) (fix e)
-    RightSection op e       -> liftM (RightSection op) $ fix e
-    RecConstr n fups        -> liftM (RecConstr n) $ mapM fix fups
-    RecUpdate e fups        -> liftM2 RecUpdate (fix e) $ mapM fix fups
-    EnumFrom e              -> liftM EnumFrom $ fix e
-    EnumFromTo e1 e2        -> liftM2 EnumFromTo (fix e1) (fix e2)
-    EnumFromThen e1 e2      -> liftM2 EnumFromThen (fix e1) (fix e2)
-    EnumFromThenTo e1 e2 e3 -> liftM3 EnumFromThenTo (fix e1) (fix e2) (fix e3)
-    ListComp e quals        -> liftM2 ListComp (fix e) $ mapM fix quals
-    ParComp  e qualss       -> liftM2 ParComp (fix e) $ mapM (mapM fix) qualss
-    ExpTypeSig loc e t      -> liftM (flip (ExpTypeSig loc) t) (fix e)
-    BracketExp b            -> liftM BracketExp $ fix b
-    SpliceExp s             -> liftM SpliceExp $ fix s
-    XTag loc n ats mexp cs  -> liftM3 (XTag loc n) (mapM fix ats) (mapM fix mexp) (mapM fix cs)
-    XETag loc n ats mexp    -> liftM2 (XETag loc n) (mapM fix ats) (mapM fix mexp)
-    XExpTag e               -> liftM XExpTag $ fix e
-    XChildTag loc cs        -> liftM (XChildTag loc) $ mapM fix cs
-    Proc loc p e            -> liftM2 (Proc loc) (fix p) (fix e)
-    LeftArrApp e1 e2        -> liftM2 LeftArrApp (fix e1) (fix e2)
-    RightArrApp e1 e2       -> liftM2 RightArrApp (fix e1) (fix e2)
-    LeftArrHighApp e1 e2    -> liftM2 LeftArrHighApp (fix e1) (fix e2)
-    RightArrHighApp e1 e2   -> liftM2 RightArrHighApp (fix e1) (fix e2)
-    CorePragma s e          -> liftM (CorePragma s) (fix e)
-    SCCPragma s e           -> liftM (SCCPragma s) (fix e)
-    GenPragma s ab cd e     -> liftM (GenPragma s ab cd) (fix e)
-
-    _                       -> return e
-  where
-    fix x = applyFixities fixs x
-
-leafFixP fixs p = case p of
-        PNeg p                -> liftM PNeg $ fix p
-        PApp n ps             -> liftM (PApp n) $ mapM fix ps
-        PTuple ps             -> liftM PTuple $ mapM fix ps
-        PList ps              -> liftM PList $ mapM fix ps
-        PParen p              -> liftM PParen $ fix p
-        PRec n pfs            -> liftM (PRec n) $ mapM fix pfs
-        PAsPat n p            -> liftM (PAsPat n) $ fix p
-        PIrrPat p             -> liftM PIrrPat $ fix p
-        PatTypeSig loc p t    -> liftM (flip (PatTypeSig loc) t) (fix p)
-        PViewPat e p          -> liftM2 PViewPat (fix e) (fix p)
-        PRPat rps             -> liftM PRPat $ mapM fix rps
-        PXTag loc n ats mp ps -> liftM3 (PXTag loc n) (mapM fix ats) (mapM fix mp) (mapM fix ps)
-        PXETag loc n ats mp   -> liftM2 (PXETag loc n) (mapM fix ats) (mapM fix mp)
-        PXPatTag p            -> liftM PXPatTag $ fix p
-        PXRPats rps           -> liftM PXRPats $ mapM fix rps
-        PBangPat p            -> liftM PBangPat $ fix p
-        _                     -> return p
-      where fix x = applyFixities fixs x
+{-# LANGUAGE CPP, DeriveDataTypeable #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  Language.Haskell.Exts.Fixity+-- Copyright   :  (c) Niklas Broberg 2009+-- License     :  BSD-style (see the file LICENSE.txt)+--+-- Maintainer  :  Niklas Broberg, d00nibro@chalmers.se+-- Stability   :  stable+-- Portability :  portable+--+-- Fixity information to give the parser so that infix operators can+-- be parsed properly.+--+-----------------------------------------------------------------------------+module Language.Haskell.Exts.Fixity+    (+    -- * Fixity representation+      Fixity(..)+    -- | The following three functions all create lists of+    --   fixities from textual representations of operators.+    --   The intended usage is e.g.+    --+    -- > fixs = infixr_ 0  ["$","$!","`seq`"]+    --+    --   Note that the operators are expected as you would+    --   write them infix, i.e. with ` characters surrounding+    --   /varid/ operators, and /varsym/ operators written as is.+    , infix_, infixl_, infixr_+    -- ** Collections of fixities+    , preludeFixities, baseFixities, prefixMinusFixity++    -- * Applying fixities to an AST+    , AppFixity(..)+    ) where++import Language.Haskell.Exts.Syntax++import Data.Char (isUpper)+import Control.Monad (when, (<=<), liftM, liftM2, liftM3, liftM4)+import Data.Traversable (mapM)+import Prelude hiding (mapM)++#ifdef __GLASGOW_HASKELL__+#ifdef BASE4+import Data.Data hiding (Fixity)+#else+import Data.Generics (Data(..),Typeable(..))+#endif+#endif++-- | Operator fixities are represented by their associativity+--   (left, right or none) and their precedence (0-9).+data Fixity = Fixity Assoc Int QName+#ifdef __GLASGOW_HASKELL__+  deriving (Eq,Ord,Show,Typeable,Data)+#else+  deriving (Eq,Ord,Show)+#endif++-- | All AST elements that may include expressions which in turn may+--   need fixity tweaking will be instances of this class.+class AppFixity ast where+  -- | Tweak any expressions in the element to account for the+  --   fixities given. Assumes that all operator expressions are+  --   fully left associative chains to begin with.+  applyFixities :: Monad m => [Fixity] -- ^ The fixities to account for.+                    -> ast  -- ^ The element to tweak.+                    -> m ast  -- ^ The same element, but with operator expressions updated, or a failure.+++instance AppFixity Exp where+  applyFixities fixs = infFix fixs <=< leafFix fixs+    where -- This is the real meat case. We can assume a left-associative list to begin with.+          infFix fixs (InfixApp a op2 z) = do+              e <- infFix fixs a+              let fixup (a1,p1) (a2,p2) y pre = do+                      when (p1 == p2 && (a1 /= a2 || a1 == AssocNone)) -- Ambiguous infix expression!+                           $ fail "Ambiguous infix expression"+                      if (p1 > p2 || p1 == p2 && (a1 == AssocLeft || a2 == AssocNone)) -- Already right order+                       then return $ InfixApp e op2 z+                       else liftM pre (infFix fixs $ InfixApp y op2 z)+              case e of+               InfixApp x op1 y -> fixup (askFixity fixs op1) (askFixity fixs op2) y (InfixApp x op1)+               NegApp         y -> fixup prefixMinusFixity    (askFixity fixs op2) y  NegApp+               _  -> return $ InfixApp e op2 z++          infFix _ e = return e++instance AppFixity Pat where+  applyFixities fixs = infFix fixs <=< leafFixP fixs+    where -- Same for patterns+          infFix fixs (PInfixApp a op2 z) = do+              p <- infFix fixs a+              let fixup (a1,p1) (a2,p2) y pre = do+                      when (p1 == p2 && (a1 /= a2 || a1 == AssocNone )) -- Ambiguous infix expression!+                           $ fail "Ambiguous infix expression"+                      if (p1 > p2 || p1 == p2 && (a1 == AssocLeft || a2 == AssocNone)) -- Already right order+                       then return $ PInfixApp p op2 z+                       else liftM pre (infFix fixs $ PInfixApp y op2 z)+              case p of+               PInfixApp x op1 y -> fixup (askFixityP fixs op1) (askFixityP fixs op2) y (PInfixApp x op1)+               PNeg            y -> fixup prefixMinusFixity     (askFixityP fixs op2) y  PNeg+               _  -> return $ PInfixApp p op2 z++          infFix _ p = return p+++-- Internal: lookup associativity and precedence of an operator+askFixity :: [Fixity] -> QOp -> (Assoc, Int)+askFixity xs k = askFix xs (f k) -- undefined -- \k -> askFixityP xs (f k) -- lookupWithDefault (AssocLeft, 9) (f k) mp+    where+        f (QVarOp x) = g x+        f (QConOp x) = g x++        g (Special Cons) = UnQual (Symbol ":")+        g x              = x++-- Same using patterns+askFixityP :: [Fixity] -> QName -> (Assoc, Int)+askFixityP xs qn = askFix xs (g qn)+    where+        g (Special Cons) = UnQual (Symbol ":")+        g x              = x+        +askFix :: [Fixity] -> QName -> (Assoc, Int)+askFix xs = \k -> lookupWithDefault (AssocLeft, 9) k mp+    where+        lookupWithDefault def k mp = case lookup k mp of+            Nothing -> def+            Just x  -> x++        mp = [(x,(a,p)) | Fixity a p x <- xs]+++-- | Built-in fixity for prefix minus+prefixMinusFixity :: (Assoc, Int)+prefixMinusFixity = (AssocLeft, 6)++-- | All fixities defined in the Prelude.+preludeFixities :: [Fixity]+preludeFixities = concat+    [infixr_ 9  ["."]+    ,infixl_ 9  ["!!"]+    ,infixr_ 8  ["^","^^","**"]+    ,infixl_ 7  ["*","/","`quot`","`rem`","`div`","`mod`",":%","%"]+    ,infixl_ 6  ["+","-"]+    ,infixr_ 5  [":","++"]+    ,infix_  4  ["==","/=","<","<=",">=",">","`elem`","`notElem`"]+    ,infixr_ 3  ["&&"]+    ,infixr_ 2  ["||"]+    ,infixl_ 1  [">>",">>="]+    ,infixr_ 1  ["=<<"]+    ,infixr_ 0  ["$","$!","`seq`"]+    ]++-- | All fixities defined in the base package.+--+--   Note that the @+++@ operator appears in both Control.Arrows and+--   Text.ParserCombinators.ReadP. The listed precedence for @+++@ in+--   this list is that of Control.Arrows.+baseFixities :: [Fixity]+baseFixities = preludeFixities ++ concat+    [infixl_ 9 ["!","//","!:"]+    ,infixl_ 8 ["`shift`","`rotate`","`shiftL`","`shiftR`","`rotateL`","`rotateR`"]+    ,infixl_ 7 [".&."]+    ,infixl_ 6 ["`xor`"]+    ,infix_  6 [":+"]+    ,infixl_ 5 [".|."]+    ,infixr_ 5 ["+:+","<++","<+>"] -- fixity conflict for +++ between ReadP and Arrow+    ,infix_  5 ["\\\\"]+    ,infixl_ 4 ["<$>","<$","<*>","<*","*>","<**>"]+    ,infix_  4 ["`elemP`","`notElemP`"]+    ,infixl_ 3 ["<|>"]+    ,infixr_ 3 ["&&&","***"]+    ,infixr_ 2 ["+++","|||"]+    ,infixr_ 1 ["<=<",">=>",">>>","<<<","^<<","<<^","^>>",">>^"]+    ,infixl_ 0 ["`on`"]+    ,infixr_ 0 ["`par`","`pseq`"]+    ]++infixr_, infixl_, infix_ :: Int -> [String] -> [Fixity]+infixr_ = fixity AssocRight+infixl_ = fixity AssocLeft+infix_  = fixity AssocNone++-- Internal: help function for the above definitions.+fixity :: Assoc -> Int -> [String] -> [Fixity]+fixity a p = map (Fixity a p . op)+    where+        op ('`':xs) = UnQual $ Ident $ init xs+        op xs = UnQual $ Symbol xs+++++++-------------------------------------------------------------------+-- Boilerplate - yuck!! Everything below here is internal stuff++instance AppFixity Module where+    applyFixities fixs (Module loc n prs mwt ext imp decls) =+        liftM (Module loc n prs mwt ext imp) $ appFixDecls fixs decls++instance AppFixity Decl where+    applyFixities fixs decl = case decl of+        ClassDecl loc ctxt n vars deps cdecls   -> liftM (ClassDecl loc ctxt n vars deps) $ mapM fix cdecls+        InstDecl loc ctxt n ts idecls           -> liftM (InstDecl loc ctxt n ts) $ mapM fix idecls+        SpliceDecl loc spl      -> liftM (SpliceDecl loc) $ fix spl+        FunBind matches         -> liftM FunBind $ mapM fix matches+        PatBind loc p mt rhs bs -> liftM3 (flip (PatBind loc) mt) (fix p) (fix rhs) (fix bs)+        AnnPragma loc ann       -> liftM (AnnPragma loc) $ fix ann+        _                       -> return decl+      where fix x = applyFixities fixs x++appFixDecls :: Monad m => [Fixity] -> [Decl] -> m [Decl]+appFixDecls fixs decls =+    let extraFixs = getFixities decls+     in mapM (applyFixities (fixs++extraFixs)) decls+  where getFixities = concatMap getFixity+        getFixity (InfixDecl _ a p ops) = map (Fixity a p . g) ops+        getFixity _ = []+        g (VarOp x) = UnQual x+        g (ConOp x) = UnQual x++instance AppFixity Annotation where+    applyFixities fixs ann = case ann of+        Ann     n e   -> liftM (Ann n) $ fix e+        TypeAnn n e   -> liftM (TypeAnn n) $ fix e+        ModuleAnn e   -> liftM ModuleAnn $ fix e+      where fix x = applyFixities fixs x++instance AppFixity ClassDecl where+    applyFixities fixs (ClsDecl decl) = liftM ClsDecl $ applyFixities fixs decl+    applyFixities _ cdecl = return cdecl++instance AppFixity InstDecl where+    applyFixities fixs (InsDecl decl) = liftM InsDecl $ applyFixities fixs decl+    applyFixities _ idecl = return idecl++instance AppFixity Match where+    applyFixities fixs (Match loc n ps mt rhs bs) = liftM3 (flip (Match loc n) mt) (mapM fix ps) (fix rhs) (fix bs)+      where fix x = applyFixities fixs x++instance AppFixity Rhs where+    applyFixities fixs rhs = case rhs of+        UnGuardedRhs e      -> liftM UnGuardedRhs $ fix e+        GuardedRhss grhss   -> liftM GuardedRhss $ mapM fix grhss+      where fix x = applyFixities fixs x++instance AppFixity GuardedRhs where+    applyFixities fixs (GuardedRhs loc stmts e) = liftM2 (GuardedRhs loc) (mapM fix stmts) $ fix e+      where fix x = applyFixities fixs x++instance AppFixity PatField where+    applyFixities fixs (PFieldPat n p) = liftM (PFieldPat n) $ applyFixities fixs p+    applyFixities _ pf = return pf++instance AppFixity RPat where+    applyFixities fixs rp = case rp of+        RPOp rp op          -> liftM (flip RPOp op) (fix rp)+        RPEither a b        -> liftM2 RPEither (fix a) (fix b)+        RPSeq rps           -> liftM RPSeq $ mapM fix rps+        RPGuard p stmts     -> liftM2 RPGuard (fix p) $ mapM fix stmts+        RPCAs n rp          -> liftM (RPCAs n) $ fix rp+        RPAs n rp           -> liftM (RPAs n) $ fix rp+        RPParen rp          -> liftM RPParen $ fix rp+        RPPat p             -> liftM RPPat $ fix p+      where fix x = applyFixities fixs x++instance AppFixity PXAttr where+    applyFixities fixs (PXAttr n p) = liftM (PXAttr n) $ applyFixities fixs p++instance AppFixity Stmt where+    applyFixities fixs stmt = case stmt of+        Generator loc p e   -> liftM2 (Generator loc) (fix p) (fix e)+        Qualifier e         -> liftM Qualifier $ fix e+        LetStmt bs          -> liftM LetStmt $ fix bs    -- special behavior+        RecStmt stmts       -> liftM RecStmt $ mapM fix stmts+      where fix x = applyFixities fixs x++instance AppFixity Binds where+    applyFixities fixs bs = case bs of+        BDecls decls        -> liftM BDecls $ appFixDecls fixs decls  -- special behavior+        IPBinds ips         -> liftM IPBinds $ mapM fix ips+      where fix x = applyFixities fixs x+++instance AppFixity IPBind where+    applyFixities fixs (IPBind loc n e) = liftM (IPBind loc n) $ applyFixities fixs e++instance AppFixity FieldUpdate where+    applyFixities fixs (FieldUpdate n e) = liftM (FieldUpdate n) $ applyFixities fixs e+    applyFixities _ fup = return fup++instance AppFixity Alt where+    applyFixities fixs (Alt loc p galts bs) = liftM3 (Alt loc) (fix p) (fix galts) (fix bs)+      where fix x = applyFixities fixs x++instance AppFixity GuardedAlts where+    applyFixities fixs galts = case galts of+        UnGuardedAlt e      -> liftM UnGuardedAlt $ fix e+        GuardedAlts  galts  -> liftM GuardedAlts $ mapM fix galts+      where fix x = applyFixities fixs x++instance AppFixity GuardedAlt where+    applyFixities fixs (GuardedAlt loc stmts e) = liftM2 (GuardedAlt loc) (mapM fix stmts) (fix e)+      where fix x = applyFixities fixs x++instance AppFixity QualStmt where+    applyFixities fixs qstmt = case qstmt of+        QualStmt     s      -> liftM QualStmt $ fix s+        ThenTrans    e      -> liftM ThenTrans $ fix e+        ThenBy       e1 e2  -> liftM2 ThenBy (fix e1) (fix e2)+        GroupBy      e      -> liftM GroupBy (fix e)+        GroupUsing   e      -> liftM GroupUsing (fix e)+        GroupByUsing e1 e2  -> liftM2 GroupByUsing (fix e1) (fix e2)+      where fix x = applyFixities fixs x++instance AppFixity Bracket where+    applyFixities fixs br = case br of+        ExpBracket e    -> liftM ExpBracket $ fix e+        PatBracket p    -> liftM PatBracket $ fix p+        DeclBracket ds  -> liftM DeclBracket $ mapM fix ds+        _               -> return br+      where fix x = applyFixities fixs x++instance AppFixity Splice where+    applyFixities fixs (ParenSplice e) = liftM ParenSplice $ applyFixities fixs e+    applyFixities _ s = return s++instance AppFixity XAttr where+    applyFixities fixs (XAttr n e) = liftM (XAttr n) $ applyFixities fixs e+++-- the boring boilerplate stuff for expressions too+-- Recursively fixes the "leaves" of the infix chains,+-- without yet touching the chain itself. We assume all chains are+-- left-associate to begin with.+leafFix fixs e = case e of+    InfixApp e1 op e2       -> liftM2 (flip InfixApp op) (leafFix fixs e1) (fix e2)+    App e1 e2               -> liftM2 App (fix e1) (fix e2)+    NegApp e                -> liftM NegApp $ fix e+    Lambda loc pats e       -> liftM2 (Lambda loc) (mapM fix pats) $ fix e+    Let bs e                -> liftM2 Let (fix bs) $ fix e+    If e a b                -> liftM3 If (fix e) (fix a) (fix b)+    Case e alts             -> liftM2 Case (fix e) $ mapM fix alts+    Do stmts                -> liftM Do $ mapM fix stmts+    MDo stmts               -> liftM MDo $ mapM fix stmts+    Tuple bx exps           -> liftM (Tuple bx) $ mapM fix exps+    List exps               -> liftM List $ mapM fix  exps+    Paren e                 -> liftM Paren $ fix e+    LeftSection e op        -> liftM (flip LeftSection op) (fix e)+    RightSection op e       -> liftM (RightSection op) $ fix e+    RecConstr n fups        -> liftM (RecConstr n) $ mapM fix fups+    RecUpdate e fups        -> liftM2 RecUpdate (fix e) $ mapM fix fups+    EnumFrom e              -> liftM EnumFrom $ fix e+    EnumFromTo e1 e2        -> liftM2 EnumFromTo (fix e1) (fix e2)+    EnumFromThen e1 e2      -> liftM2 EnumFromThen (fix e1) (fix e2)+    EnumFromThenTo e1 e2 e3 -> liftM3 EnumFromThenTo (fix e1) (fix e2) (fix e3)+    ListComp e quals        -> liftM2 ListComp (fix e) $ mapM fix quals+    ParComp  e qualss       -> liftM2 ParComp (fix e) $ mapM (mapM fix) qualss+    ExpTypeSig loc e t      -> liftM (flip (ExpTypeSig loc) t) (fix e)+    BracketExp b            -> liftM BracketExp $ fix b+    SpliceExp s             -> liftM SpliceExp $ fix s+    XTag loc n ats mexp cs  -> liftM3 (XTag loc n) (mapM fix ats) (mapM fix mexp) (mapM fix cs)+    XETag loc n ats mexp    -> liftM2 (XETag loc n) (mapM fix ats) (mapM fix mexp)+    XExpTag e               -> liftM XExpTag $ fix e+    XChildTag loc cs        -> liftM (XChildTag loc) $ mapM fix cs+    Proc loc p e            -> liftM2 (Proc loc) (fix p) (fix e)+    LeftArrApp e1 e2        -> liftM2 LeftArrApp (fix e1) (fix e2)+    RightArrApp e1 e2       -> liftM2 RightArrApp (fix e1) (fix e2)+    LeftArrHighApp e1 e2    -> liftM2 LeftArrHighApp (fix e1) (fix e2)+    RightArrHighApp e1 e2   -> liftM2 RightArrHighApp (fix e1) (fix e2)+    CorePragma s e          -> liftM (CorePragma s) (fix e)+    SCCPragma s e           -> liftM (SCCPragma s) (fix e)+    GenPragma s ab cd e     -> liftM (GenPragma s ab cd) (fix e)++    _                       -> return e+  where+    fix x = applyFixities fixs x++leafFixP fixs p = case p of+        PInfixApp p1 op p2    -> liftM2 (flip PInfixApp op) (leafFixP fixs p1) (fix p2)+        PNeg p                -> liftM PNeg $ fix p+        PApp n ps             -> liftM (PApp n) $ mapM fix ps+        PTuple bx ps          -> liftM (PTuple bx) $ mapM fix ps+        PList ps              -> liftM PList $ mapM fix ps+        PParen p              -> liftM PParen $ fix p+        PRec n pfs            -> liftM (PRec n) $ mapM fix pfs+        PAsPat n p            -> liftM (PAsPat n) $ fix p+        PIrrPat p             -> liftM PIrrPat $ fix p+        PatTypeSig loc p t    -> liftM (flip (PatTypeSig loc) t) (fix p)+        PViewPat e p          -> liftM2 PViewPat (fix e) (fix p)+        PRPat rps             -> liftM PRPat $ mapM fix rps+        PXTag loc n ats mp ps -> liftM3 (PXTag loc n) (mapM fix ats) (mapM fix mp) (mapM fix ps)+        PXETag loc n ats mp   -> liftM2 (PXETag loc n) (mapM fix ats) (mapM fix mp)+        PXPatTag p            -> liftM PXPatTag $ fix p+        PXRPats rps           -> liftM PXRPats $ mapM fix rps+        PBangPat p            -> liftM PBangPat $ fix p+        _                     -> return p+      where fix x = applyFixities fixs x
src/Language/Haskell/Exts/InternalLexer.hs view
@@ -187,12 +187,14 @@         | KW_Safe         | KW_Unsafe         | KW_Threadsafe+        | KW_Interruptible         | KW_StdCall         | KW_CCall         | KW_CPlusPlus         | KW_DotNet         | KW_Jvm         | KW_Js+        | KW_CApi          | EOF         deriving (Eq,Show)@@ -285,16 +287,18 @@  ( "hiding",    (KW_Hiding,     Nothing) ),  -- FFI- ( "export",     (KW_Export,        Just (Any [ForeignFunctionInterface])) ),- ( "safe",       (KW_Safe,          Just (Any [ForeignFunctionInterface])) ),- ( "unsafe",     (KW_Unsafe,        Just (Any [ForeignFunctionInterface])) ),- ( "threadsafe", (KW_Threadsafe,    Just (Any [ForeignFunctionInterface])) ),- ( "stdcall",    (KW_StdCall,       Just (Any [ForeignFunctionInterface])) ),- ( "ccall",      (KW_CCall,         Just (Any [ForeignFunctionInterface])) ),- ( "cplusplus",  (KW_CPlusPlus,     Just (Any [ForeignFunctionInterface])) ),- ( "dotnet",     (KW_DotNet,        Just (Any [ForeignFunctionInterface])) ),- ( "jvm",        (KW_Jvm,           Just (Any [ForeignFunctionInterface])) ),- ( "js",         (KW_Js,            Just (Any [ForeignFunctionInterface])) )+ ( "export",        (KW_Export,        Just (Any [ForeignFunctionInterface])) ),+ ( "safe",          (KW_Safe,          Just (Any [ForeignFunctionInterface])) ),+ ( "unsafe",        (KW_Unsafe,        Just (Any [ForeignFunctionInterface])) ),+ ( "threadsafe",    (KW_Threadsafe,    Just (Any [ForeignFunctionInterface])) ),+ ( "interruptible", (KW_Interruptible, Just (Any [InterruptibleFFI])) ),+ ( "stdcall",       (KW_StdCall,       Just (Any [ForeignFunctionInterface])) ),+ ( "ccall",         (KW_CCall,         Just (Any [ForeignFunctionInterface])) ),+ ( "cplusplus",     (KW_CPlusPlus,     Just (Any [ForeignFunctionInterface])) ),+ ( "dotnet",        (KW_DotNet,        Just (Any [ForeignFunctionInterface])) ),+ ( "jvm",           (KW_Jvm,           Just (Any [ForeignFunctionInterface])) ),+ ( "js",            (KW_Js,            Just (Any [ForeignFunctionInterface])) ),+ ( "capi",          (KW_CApi,          Just (Any [CApiFFI])) )  ]  pragmas :: [(String,Token)]@@ -340,7 +344,8 @@ topLexer = do     b <- pullCtxtFlag     if b then -- trace (show cf ++ ": " ++ show VRightCurly) $-              setBOL >> getSrcLocL >>= \l -> return (Loc (mkSrcSpan l l) VRightCurly) -- the lex context state flags that we must do an empty {} - UGLY+              -- the lex context state flags that we must do an empty {} - UGLY+              setBOL >> getSrcLocL >>= \l -> return (Loc (mkSrcSpan l l) VRightCurly)      else do         bol <- checkBOL         (bol, ws) <- lexWhiteSpace bol@@ -366,7 +371,7 @@     case s of         -- If we find a recognised pragma, we don't want to treat it as a comment.         '{':'-':'#':rest | isRecognisedPragma rest -> return (bol, False)-                         | isLinePragma rest && not ignL -> do +                         | isLinePragma rest && not ignL -> do                             (l, fn) <- lexLinePragma                             setSrcLineL l                             setLineFilenameL fn@@ -584,17 +589,20 @@ lexStdToken = do     s <- getInput     exts <- getExtensionsL+    let intHash = lexHash IntTok IntTokHash (Right WordTokHash)     case s of         [] -> return EOF          '0':c:d:_ | toLower c == 'o' && isOctDigit d -> do                         discard 2                         (n, str) <- lexOctal-                        return (IntTok (n, '0':c:str))+                        con <- intHash+                        return (con (n, '0':c:str))                   | toLower c == 'x' && isHexDigit d -> do                         discard 2                         (n, str) <- lexHexadecimal-                        return (IntTok (n, '0':c:str))+                        con <- intHash+                        return (con (n, '0':c:str))          -- implicit parameters         '?':c:_ | isLower c && ImplicitParams `elem` exts -> do@@ -658,7 +666,7 @@         -- end template haskell          -- hsx-        '<':'%':c:_ | XmlSyntax `elem` exts -> do +        '<':'%':c:_ | XmlSyntax `elem` exts -> do                         case c of                          '>' -> do discard 3                                    pushExtContextL ChildCtxt@@ -962,8 +970,8 @@                                               _   -> QVarSym (qual', sym)            '#':cs-            | null cs || -              not (isHSymbol $ head cs) && +            | null cs ||+              not (isHSymbol $ head cs) &&               not (isIdent $ head cs) && MagicHash `elem` exts -> do                 discard 1                 case conid of@@ -1152,7 +1160,11 @@     foldl1 (\n d -> n * radix + d) (map (toInteger . digitToInt) ds)  flagKW :: Token -> Lex a ()-flagKW t = when (t `elem` [KW_Do, KW_MDo]) flagDo+flagKW t = do+  when (t `elem` [KW_Do, KW_MDo]) $ do+       exts <- getExtensionsL+       when (NondecreasingIndentation `elem` exts) $+            flagDo  ------------------------------------------------------------------ -- "Pretty" printing for tokens@@ -1291,6 +1303,7 @@   KW_Safe       -> "safe"   KW_Unsafe     -> "unsafe"   KW_Threadsafe -> "threadsafe"+  KW_Interruptible -> "interruptible"   KW_StdCall    -> "stdcall"   KW_CCall      -> "ccall" 
src/Language/Haskell/Exts/InternalParser.ly view
@@ -213,12 +213,14 @@ >       'safe'          { Loc $$ KW_Safe } >       'unsafe'        { Loc $$ KW_Unsafe } >       'threadsafe'    { Loc $$ KW_Threadsafe }+>       'interruptible' { Loc $$ KW_Interruptible } >       'stdcall'       { Loc $$ KW_StdCall } >       'ccall'         { Loc $$ KW_CCall } >       'cplusplus'     { Loc $$ KW_CPlusPlus } >       'dotnet'        { Loc $$ KW_DotNet } >       'jvm'           { Loc $$ KW_Jvm } >       'js'            { Loc $$ KW_Js }+>       'capi'          { Loc $$ KW_CApi }  Reserved Ids @@ -639,10 +641,11 @@ > specinldecl :: { Decl L } >       : '{-# INLINE' activation qvar '#-}'             { let Loc l (INLINE s) = $1 in InlineSig (l <^^> $4 <** [l,$4]) s $2 $3 } >       | '{-# INLINE_CONLIKE' activation qvar '#-}'     { InlineConlikeSig ($1 <^^> $4 <** [$1,$4]) $2 $3 }->       | '{-# SPECIALISE' qvar '::' sigtypes '#-}'      { SpecSig ($1 <^^> $5 <** ($1:$3 : snd $4 ++ [$5])) $2 (fst $4) }+>       | '{-# SPECIALISE' activation qvar '::' sigtypes '#-}'      +>             { SpecSig ($1 <^^> $6 <** ($1: $4 : snd $5 ++ [$6])) $2 $3 (fst $5) } >       | '{-# SPECIALISE_INLINE' activation qvar '::' sigtypes '#-}'->                                                        { let Loc l (SPECIALISE_INLINE s) = $1->                                                           in SpecInlineSig (l <^^> $6 <** (l:$4:snd $5++[$6])) s $2 $3 (fst $5) }+>             { let Loc l (SPECIALISE_INLINE s) = $1+>                in SpecInlineSig (l <^^> $6 <** (l:$4:snd $5++[$6])) s $2 $3 (fst $5) } >       | '{-# SPECIALISE' 'instance' ctype '#-}'        {% do { (cs,ih) <- checkInstHeader $3; >                                                                let {l = $1 <^^> $4 <** [$1,$2,$4]}; >                                                                return $ InstSig l cs ih } }@@ -692,12 +695,14 @@ >          | 'dotnet'                   { DotNet    (nIS $1) } >          | 'jvm'                      { Jvm       (nIS $1) } >          | 'js'                       { Js        (nIS $1) }+>          | 'capi'                     { CApi      (nIS $1) }   > safety :: { Maybe (Safety L) } >        : 'safe'                       { Just $ PlaySafe  (nIS $1) False } >        | 'unsafe'                     { Just $ PlayRisky (nIS $1) } >        | 'threadsafe'                 { Just $ PlaySafe  (nIS $1) True }+>        | 'interruptible'              { Just $ PlayInterruptible (nIS $1) } >        | {- empty -}                  { Nothing }  > fspec :: { (Maybe String, Name L, Type L, [S]) }@@ -1262,11 +1267,17 @@ >       | gcon                          { $1 } >       | literal                       { Lit (ann $1) $1 } >       | '(' texp ')'                  { Paren ($1 <^^> $3 <** [$1,$3]) $2 }->       | '(' texp tsectend             { TupleSection ($1 <^^> head (snd $3) <** $1:reverse (snd $3)) (Just $2 : fst $3) }->       | '(' commas texp ')'           { TupleSection ($1 <^^> $4 <** $1:reverse ($4:$2))+>       | '(' texp tsectend             { TupleSection ($1 <^^> head (snd $3) <** $1:reverse (snd $3)) Boxed (Just $2 : fst $3) }+>       | '(' commas texp ')'           { TupleSection ($1 <^^> $4 <** $1:reverse ($4:$2)) Boxed >                                                       (replicate (length $2) Nothing ++ [Just $3]) }->       | '(' commas texp tsectend      { TupleSection ($1 <^^> head (snd $4) <** $1:reverse (snd $4 ++ $2))+>       | '(' commas texp tsectend      { TupleSection ($1 <^^> head (snd $4) <** $1:reverse (snd $4 ++ $2)) Boxed >                                                       (replicate (length $2) Nothing ++ Just $3 : fst $4) }+>       | '(#' texp thashsectend        { TupleSection ($1 <^^> head (snd $3) <** $1:reverse (snd $3)) Unboxed (Just $2 : fst $3) }+>       | '(#' texp '#)'                { TupleSection ($1 <^^> $3 <** [$1,$3]) Unboxed [Just $2] }+>       | '(#' commas texp '#)'         { TupleSection ($1 <^^> $4 <** $1:reverse ($4:$2)) Unboxed+>                                                       (replicate (length $2) Nothing ++ [Just $3]) }+>       | '(#' commas texp thashsectend { TupleSection ($1 <^^> head (snd $4) <** $1:reverse (snd $4 ++ $2)) Unboxed+>                                                       (replicate (length $2) Nothing ++ Just $3 : fst $4) } >       | '[' list ']'                  { amap (\l -> l <** [$3]) $ $2 ($1 <^^> $3 <** [$1]) } >       | '_'                           { WildCard (nIS $1) } >       | '(' erpats ')'                {% checkEnabled RegularPatterns >> return (Paren ($1 <^^> $3 <** [$1,$3]) $2) }@@ -1303,6 +1314,11 @@ >       : commas texp tsectend          { let (mes, ss) = $3 in (replicate (length $1 - 1) Nothing ++ Just $2 : mes, ss ++ $1) } >       | commas texp ')'               { (replicate (length $1 - 1) Nothing ++ [Just $2], $3 : $1) } >       | commas ')'                    { (replicate (length $1) Nothing, $2 : $1) }++> thashsectend :: { ([Maybe (PExp L)],[S]) }+>       : commas texp thashsectend      { let (mes, ss) = $3 in (replicate (length $1 - 1) Nothing ++ Just $2 : mes, ss ++ $1) }+>       | commas texp '#)'              { (replicate (length $1 - 1) Nothing ++ [Just $2], $3 : $1) }+>       | commas '#)'                   { (replicate (length $1) Nothing, $2 : $1) }  ----------------------------------------------------------------------------- Harp Extensions
src/Language/Haskell/Exts/ParseMonad.hs view
@@ -36,7 +36,7 @@ import Language.Haskell.Exts.SrcLoc(SrcLoc(..)) import Language.Haskell.Exts.Fixity (Fixity, preludeFixities) import Language.Haskell.Exts.Comments-import Language.Haskell.Exts.Extension (Extension, impliesExts, haskell2010)+import Language.Haskell.Exts.Extension -- (Extension, impliesExts, haskell2010)  import Data.List ( intersperse ) import Control.Applicative@@ -110,6 +110,8 @@ data ParseMode = ParseMode {         -- | original name of the file being parsed         parseFilename :: String,+        -- | base language (e.g. Haskell98, Haskell2010)+        baseLanguage :: Language,         -- | list of extensions enabled for parsing         extensions :: [Extension],         -- | if 'True', the parser won't care about further extensions@@ -130,21 +132,38 @@ defaultParseMode :: ParseMode defaultParseMode = ParseMode {         parseFilename = "<unknown>.hs",-        extensions = haskell2010,+        baseLanguage = Haskell2010,+        extensions = [],         ignoreLanguagePragmas = False,         ignoreLinePragmas = True,         fixities = Just preludeFixities         } +-- Version of ParseMode used internally,+-- where the language and extensions have+-- been expanded+data InternalParseMode = IParseMode {+        iParseFilename :: String,+        iExtensions :: [KnownExtension],+        iIgnoreLanguagePragmas :: Bool,+        iIgnoreLinePragmas :: Bool,+        iFixities :: Maybe [Fixity]+    }++toInternalParseMode :: ParseMode -> InternalParseMode+toInternalParseMode (ParseMode pf bLang exts ilang iline fx) =+    IParseMode pf (impliesExts $ toExtensionList bLang exts) ilang iline fx++ -- | Monad for parsing  newtype P a = P { runP ::-                String      -- input string-             -> Int     -- current column-             -> Int     -- current line-             -> SrcLoc      -- location of last token read-             -> ParseState  -- layout info.-             -> ParseMode   -- parse parameters+                String              -- input string+             -> Int                 -- current column+             -> Int                 -- current line+             -> SrcLoc              -- location of last token read+             -> ParseState          -- layout info.+             -> InternalParseMode   -- parse parameters              -> ParseStatus a         } @@ -164,7 +183,8 @@ runParser = runParserWithMode defaultParseMode  runParserWithModeComments :: ParseMode -> P a -> String -> ParseResult (a, [Comment])-runParserWithModeComments mode (P m) s = case m s 0 1 start ([],[],(False,False),[]) (allExts mode) of+runParserWithModeComments mode (P m) s = +  case m s 0 1 start ([],[],(False,False),[]) (toInternalParseMode mode) of     Ok (_,_,_,cs) a -> ParseOk (a, reverse cs)     Failed loc msg -> ParseFailed loc msg     where start = SrcLoc {@@ -172,8 +192,10 @@         srcLine = 1,         srcColumn = 1         }-          allExts mode@(ParseMode {extensions = es}) = mode { extensions = impliesExts es }+  --        allExts mode@(ParseMode {extensions = es}) = mode { extensions = impliesExts es } +    --      allExts mode = let imode = to+ instance Monad P where     return a = P $ \_i _x _y _l s _m -> Ok s a     P m >>= k = P $ \i x y l s mode ->@@ -190,7 +212,7 @@  getModuleName :: P String getModuleName = P $ \_i _x _y _l s m ->-    let fn = parseFilename m+    let fn = iParseFilename m         mn = concat $ intersperse "." $ splitPath fn          splitPath :: String -> [String]@@ -248,9 +270,9 @@   -- Extension-aware lexing/parsing-getExtensions :: P [Extension]+getExtensions :: P [KnownExtension] getExtensions = P $ \_i _x _y _l s m ->-    Ok s $ extensions m+    Ok s $ iExtensions m  pushCtxtFlag :: P () pushCtxtFlag =@@ -287,7 +309,10 @@ -- | Discard the next character, which must be a newline.  lexNewline :: Lex a ()-lexNewline = Lex $ \cont -> P $ \(_:r) _x y -> runP (cont ()) r 1 (y+1)+lexNewline = Lex $ \cont -> P $ \rs _x y loc ->+  case rs of+    (_:r) -> runP (cont ()) r 1 (y+1) loc+    []    -> \_ _ -> Failed loc "Lexer: expected newline."  -- | Discard the next character, which must be a tab. @@ -343,7 +368,7 @@ startToken :: Lex a () startToken = Lex $ \cont -> P $ \s x y _ stk mode ->     let loc = SrcLoc {-        srcFilename = parseFilename mode,+        srcFilename = iParseFilename mode,         srcLine = y,         srcColumn = x     } in@@ -406,20 +431,20 @@  -- Extension-aware lexing -getExtensionsL :: Lex a [Extension]+getExtensionsL :: Lex a [KnownExtension] getExtensionsL = Lex $ \cont -> P $ \r x y loc s m ->-        runP (cont $ extensions m) r x y loc s m+        runP (cont $ iExtensions m) r x y loc s m  -- LINE-aware lexing  ignoreLinePragmasL :: Lex a Bool ignoreLinePragmasL = Lex $ \cont -> P $ \r x y loc s m ->-        runP (cont $ ignoreLinePragmas m) r x y loc s m+        runP (cont $ iIgnoreLinePragmas m) r x y loc s m  -- If we read a file name in a LINE pragma, we should update the state. setLineFilenameL :: String -> Lex a () setLineFilenameL name = Lex $ \cont -> P $ \r x y loc s m ->-        runP (cont ()) r x y loc s (m {parseFilename = name})+        runP (cont ()) r x y loc s (m {iParseFilename = name})          -- Comments 
src/Language/Haskell/Exts/ParseSyntax.hs view
@@ -1,440 +1,440 @@-{-# OPTIONS_HADDOCK hide #-}
-module Language.Haskell.Exts.ParseSyntax where
-
-import Language.Haskell.Exts.Annotated.Syntax hiding ( Type(..), Asst(..), Exp(..), FieldUpdate(..), XAttr(..), Context(..) )
-import qualified Language.Haskell.Exts.Annotated.Syntax as S ( Type(..), Asst(..), Exp(..), FieldUpdate(..), XAttr(..), Context(..) )
-
----------------------------------------
--- Expressions as we parse them (and patters, and regular patterns)
-
-data PExp l
-    = Var l (QName l)                       -- ^ variable
-    | IPVar l (IPName l)                    -- ^ implicit parameter variable
-    | Con l (QName l)                       -- ^ data constructor
-    | Lit l (Literal l)                     -- ^ literal constant
-    | InfixApp l (PExp l) (QOp l) (PExp l)  -- ^ infix application
-    | App l (PExp l) (PExp l)               -- ^ ordinary application
-    | NegApp l (PExp l)                     -- ^ negation expression @-@ /exp/
-    | Lambda l [Pat l] (PExp l)             -- ^ lambda expression
-    | Let l (Binds l) (PExp l)              -- ^ local declarations with @let@
-    | If l (PExp l) (PExp l) (PExp l)       -- ^ @if@ /exp/ @then@ /exp/ @else@ /exp/
-    | Case l (PExp l) [Alt l]               -- ^ @case@ /exp/ @of@ /alts/
-    | Do l [Stmt l]                         -- ^ @do@-expression:
-                                            --   the last statement in the list
-                                            --   should be an expression.
-    | MDo l [Stmt l]                        -- ^ @mdo@-expression
---    | Tuple [PExp]                        -- ^ tuple expression
-    | TupleSection l [Maybe (PExp l)]       -- ^ tuple section expression, e.g. @(,,3)@
-    | List l [PExp l]                       -- ^ list expression
-    | Paren l (PExp l)                      -- ^ parenthesized expression
---     RightSection QOp PExp                -- ^ right section @(@/qop/ /exp/@)@
-    | RecConstr l (QName l) [PFieldUpdate l]
-                                            -- ^ record construction expression
-    | RecUpdate l (PExp l) [PFieldUpdate l]
-                                            -- ^ record update expression
-    | EnumFrom l (PExp l)                   -- ^ unbounded arithmetic sequence,
-                                            --   incrementing by 1
-    | EnumFromTo l (PExp l) (PExp l)        -- ^ bounded arithmetic sequence,
-                                            --   incrementing by 1
-    | EnumFromThen l (PExp l) (PExp l)      -- ^ unbounded arithmetic sequence,
-                                            --   with first two elements given
-    | EnumFromThenTo l (PExp l) (PExp l) (PExp l)
-                                            -- ^ bounded arithmetic sequence,
-                                            --   with first two elements given
-    | ParComp l (PExp l) [[QualStmt l]]     -- ^ parallel list comprehension
-    | ExpTypeSig l (PExp l) (S.Type l)      -- ^ expression type signature
-    | AsPat l (Name l) (PExp l)             -- ^ patterns only
-    | WildCard l                            -- ^ patterns only
-    | IrrPat l (PExp l)                     -- ^ patterns only
-
--- Post-ops for parsing left sections and regular patterns. Not to be left in the final tree.
-    | PostOp l (PExp l) (QOp l)             -- ^ post-ops
-    | PreOp l (QOp l) (PExp l)              -- ^ pre-ops
-
--- View patterns
-    | ViewPat l (PExp l) (PExp l)           -- ^ patterns only
-
--- HaRP
-    | SeqRP l [PExp l]                      -- ^ regular patterns only
-    | GuardRP l (PExp l) [Stmt l]           -- ^ regular patterns only
-    | EitherRP l (PExp l) (PExp l)          -- ^ regular patterns only
-    | CAsRP l (Name l) (PExp l)             -- ^ regular patterns only
-
--- Template Haskell
-    | VarQuote l (QName l)                  -- ^ 'x
-    | TypQuote l (QName l)                  -- ^ ''T
-    | BracketExp l (Bracket l)
-    | SpliceExp l (Splice l)
-    | QuasiQuote l String String            -- ^ [$...|...]
-
--- Hsx
-    | XTag  l (XName l) [ParseXAttr l] (Maybe (PExp l)) [PExp l]
-                                            -- ^ <Name>...</Name>
-    | XETag l (XName l) [ParseXAttr l] (Maybe (PExp l))
-                                            -- ^ <Name />
-    | XPcdata l String                      -- ^ PCDATA
-    | XExpTag l (PExp l)                    -- ^ <% ... %>
-    | XChildTag l [PExp l]                  -- ^ <%> ... </%>
-    | XRPats l [PExp l]                     -- ^ <[ ... ]>
-
--- Pragmas
-    | CorePragma l      String  (PExp l)    -- ^ {-# CORE #-} pragma
-    | SCCPragma  l      String  (PExp l)    -- ^ {-# SCC #-} pragma
-    | GenPragma  l      String (Int, Int) (Int, Int) (PExp l)
-                                            -- ^ {-# GENERATED ... #-} pragma
-
--- Generics
-    | ExplTypeArg l (QName l) (S.Type l)    -- ^ f {| Int |} x = ...
-
--- Bang Patterns
-    | BangPat l (PExp l)                    -- ^ f !a = ...
-
--- Arrows
-    | Proc l (Pat l) (PExp l)               -- ^ proc p -> do
-    | LeftArrApp      l (PExp l) (PExp l)   -- ^ e -< e
-    | RightArrApp     l (PExp l) (PExp l)   -- ^ e >- e
-    | LeftArrHighApp  l (PExp l) (PExp l)   -- ^ e -<< e
-    | RightArrHighApp l (PExp l) (PExp l)   -- ^ e >>- e
-   deriving (Eq,Show)
-
-data PFieldUpdate l
-    = FieldUpdate l (QName l) (PExp l)
-    | FieldPun l (Name l)
-    | FieldWildcard l
-  deriving (Eq,Show)
-
-data ParseXAttr l = XAttr l (XName l) (PExp l)
-  deriving (Eq,Show)
-
-instance Annotated PExp where
-    ann e = case e of
-        Var l qn        -> l
-        IPVar l ipn     -> l
-        Con l qn        -> l
-        Lit l lit       -> l
-        InfixApp l e1 qop e2    -> l
-        App l e1 e2     -> l
-        NegApp l e      -> l
-        Lambda l ps e   -> l
-        Let l bs e      -> l
-        If l ec et ee   -> l
-        Case l e alts   -> l
-        Do l ss         -> l
-        MDo l ss        -> l
-        TupleSection l mes  -> l
-        List l es       -> l
-        Paren l e       -> l
-        RecConstr l qn fups     -> l
-        RecUpdate l e  fups     -> l
-        EnumFrom l e            -> l
-        EnumFromTo l ef et      -> l
-        EnumFromThen l ef et    -> l
-        EnumFromThenTo l ef eth eto -> l
-        ParComp  l e qsss       -> l
-        ExpTypeSig l e t        -> l
-        AsPat l n e             -> l
-        WildCard l              -> l
-        IrrPat l e              -> l
-        PostOp l e op           -> l
-        PreOp l op e            -> l
-        ViewPat l e1 e2         -> l
-        SeqRP l es              -> l
-        GuardRP l e ss          -> l
-        EitherRP l e1 e2        -> l
-        CAsRP l n e             -> l
-
-        VarQuote l qn           -> l
-        TypQuote l qn           -> l
-        BracketExp l br         -> l
-        SpliceExp l sp          -> l
-        QuasiQuote l sn se      -> l
-
-        XTag  l xn xas me es    -> l
-        XETag l xn xas me       -> l
-        XPcdata l s             -> l
-        XExpTag l e             -> l
-        XChildTag l es          -> l
-        XRPats l es             -> l
-
-        CorePragma l s e   -> l
-        SCCPragma  l s e   -> l
-        GenPragma  l s n12 n34 e -> l
-
-        ExplTypeArg l qn t      -> l
-        BangPat l e             -> l
-
-        Proc            l p e   -> l
-        LeftArrApp      l e1 e2 -> l
-        RightArrApp     l e1 e2 -> l
-        LeftArrHighApp  l e1 e2 -> l
-        RightArrHighApp l e1 e2 -> l
-
-    amap f e = case e of
-        Var l qn                -> Var   (f l) qn
-        IPVar l ipn             -> IPVar (f l) ipn
-        Con l qn                -> Con   (f l) qn
-        Lit l lit               -> Lit   (f l) lit
-        InfixApp l e1 qop e2    -> InfixApp (f l) e1 qop e2
-        App l e1 e2             -> App (f l) e1 e2
-        NegApp l e              -> NegApp (f l) e
-        Lambda l ps e           -> Lambda (f l) ps e
-        Let l bs e              -> Let (f l) bs e
-        If l ec et ee           -> If (f l) ec et ee
-        Case l e alts           -> Case (f l) e alts
-        Do l ss                 -> Do (f l) ss
-        MDo l ss                -> MDo (f l) ss
-        TupleSection l mes      -> TupleSection (f l) mes
-        List l es               -> List (f l) es
-        Paren l e               -> Paren (f l) e
-        RecConstr l qn fups     -> RecConstr (f l) qn fups
-        RecUpdate l e  fups     -> RecUpdate (f l) e  fups
-        EnumFrom l e            -> EnumFrom (f l) e
-        EnumFromTo l ef et      -> EnumFromTo (f l) ef et
-        EnumFromThen l ef et    -> EnumFromThen (f l) ef et
-        EnumFromThenTo l ef eth eto -> EnumFromThenTo (f l) ef eth eto
-        ParComp  l e qsss       -> ParComp  (f l) e qsss
-        ExpTypeSig l e t        -> ExpTypeSig (f l) e t
-
-        AsPat l n e             -> AsPat (f l) n e
-        WildCard l              -> WildCard (f l)
-        IrrPat l e              -> IrrPat (f l) e
-        PostOp l e op           -> PostOp (f l) e op
-        PreOp l op e            -> PreOp (f l) op e
-        ViewPat l e1 e2         -> ViewPat (f l) e1 e2
-        SeqRP l es              -> SeqRP (f l) es
-        GuardRP l e ss          -> GuardRP (f l) e ss
-        EitherRP l e1 e2        -> EitherRP (f l) e1 e2
-        CAsRP l n e             -> CAsRP (f l) n e
-        ExplTypeArg l n t       -> ExplTypeArg (f l) n t
-        BangPat l e             -> BangPat (f l) e
-
-        VarQuote l qn           -> VarQuote (f l) qn
-        TypQuote l qn           -> TypQuote (f l) qn
-        BracketExp l br         -> BracketExp (f l) br
-        SpliceExp l sp          -> SpliceExp (f l) sp
-        QuasiQuote l sn se      -> QuasiQuote (f l) sn se
-
-        XTag  l xn xas me es    -> XTag  (f l) xn xas me es
-        XETag l xn xas me       -> XETag (f l) xn xas me
-        XPcdata l s             -> XPcdata (f l) s
-        XExpTag l e             -> XExpTag (f l) e
-        XChildTag l es          -> XChildTag (f l) es
-        XRPats l es             -> XRPats (f l) es
-
-        CorePragma l s e        -> CorePragma (f l) s e
-        SCCPragma  l s e        -> SCCPragma  (f l) s e
-        GenPragma  l s n12 n34 e -> GenPragma  (f l) s n12 n34 e
-
-        Proc            l p e   -> Proc            (f l) p e
-        LeftArrApp      l e1 e2 -> LeftArrApp      (f l) e1 e2
-        RightArrApp     l e1 e2 -> RightArrApp     (f l) e1 e2
-        LeftArrHighApp  l e1 e2 -> LeftArrHighApp  (f l) e1 e2
-        RightArrHighApp l e1 e2 -> RightArrHighApp (f l) e1 e2
-
-instance Functor PExp where
-      fmap f e = case e of
-          Var l qn                -> Var   (f l) (fmap f qn)
-          IPVar l ipn             -> IPVar (f l) (fmap f ipn)
-          Con l qn                -> Con   (f l) (fmap f qn)
-          Lit l lit               -> Lit   (f l) (fmap f lit)
-          InfixApp l e1 qop e2    -> InfixApp (f l) (fmap f e1) (fmap f qop) (fmap f e2)
-          App l e1 e2             -> App (f l) (fmap f e1) (fmap f e2)
-          NegApp l e              -> NegApp (f l) (fmap f e)
-          Lambda l ps e           -> Lambda (f l) (map (fmap f) ps) (fmap f e)
-          Let l bs e              -> Let (f l) (fmap f bs) (fmap f e)
-          If l ec et ee           -> If (f l) (fmap f ec) (fmap f et) (fmap f ee)
-          Case l e alts           -> Case (f l) (fmap f e) (map (fmap f) alts)
-          Do l ss                 -> Do (f l) (map (fmap f) ss)
-          MDo l ss                -> MDo (f l) (map (fmap f) ss)
-          TupleSection l mes      -> TupleSection (f l) (map (fmap (fmap f)) mes)
-          List l es               -> List (f l) (map (fmap f) es)
-          Paren l e               -> Paren (f l) (fmap f e)
-          RecConstr l qn fups     -> RecConstr (f l) (fmap f qn) (map (fmap f) fups)
-          RecUpdate l e  fups     -> RecUpdate (f l) (fmap f e)  (map (fmap f) fups)
-          EnumFrom l e            -> EnumFrom (f l) (fmap f e)
-          EnumFromTo l ef et      -> EnumFromTo (f l) (fmap f ef) (fmap f et)
-          EnumFromThen l ef et    -> EnumFromThen (f l) (fmap f ef) (fmap f et)
-          EnumFromThenTo l ef eth eto -> EnumFromThenTo (f l) (fmap f ef) (fmap f eth) (fmap f eto)
-          ParComp  l e qsss       -> ParComp  (f l) (fmap f e) (map (map (fmap f)) qsss)
-          ExpTypeSig l e t        -> ExpTypeSig (f l) (fmap f e) (fmap f t)
-
-          AsPat l n e             -> AsPat (f l) (fmap f n) (fmap f e)
-          WildCard l              -> WildCard (f l)
-          IrrPat l e              -> IrrPat (f l) (fmap f e)
-          PostOp l e op           -> PostOp (f l) (fmap f e) (fmap f op)
-          PreOp l op e            -> PreOp (f l) (fmap f op) (fmap f e)
-          ViewPat l e1 e2         -> ViewPat (f l) (fmap f e1) (fmap f e2)
-          SeqRP l es              -> SeqRP (f l) (map (fmap f) es)
-          GuardRP l e ss          -> GuardRP (f l) (fmap f e) (map (fmap f) ss)
-          EitherRP l e1 e2        -> EitherRP (f l) (fmap f e1) (fmap f e2)
-          CAsRP l n e             -> CAsRP (f l) (fmap f n) (fmap f e)
-          ExplTypeArg l n t       -> ExplTypeArg (f l) (fmap f n) (fmap f t)
-          BangPat l e             -> BangPat (f l) (fmap f e)
-
-          VarQuote l qn           -> VarQuote (f l) (fmap f qn)
-          TypQuote l qn           -> TypQuote (f l) (fmap f qn)
-          BracketExp l br         -> BracketExp (f l) (fmap f br)
-          SpliceExp l sp          -> SpliceExp (f l) (fmap f sp)
-          QuasiQuote l sn se      -> QuasiQuote (f l) sn se
-
-          XTag  l xn xas me es    -> XTag  (f l) (fmap f xn) (map (fmap f) xas) (fmap (fmap f) me) (map (fmap f) es)
-          XETag l xn xas me       -> XETag (f l) (fmap f xn) (map (fmap f) xas) (fmap (fmap f) me)
-          XPcdata l s             -> XPcdata (f l) s
-          XExpTag l e             -> XExpTag (f l) (fmap f e)
-          XChildTag l es          -> XChildTag (f l) (map (fmap f) es)
-          XRPats l es             -> XRPats (f l) (map (fmap f) es)
-
-          CorePragma l s e        -> CorePragma (f l) s (fmap f e)
-          SCCPragma  l s e        -> SCCPragma  (f l) s (fmap f e)
-          GenPragma  l s n12 n34 e -> GenPragma  (f l) s n12 n34 (fmap f e)
-
-          Proc            l p e   -> Proc            (f l) (fmap f p) (fmap f e)
-          LeftArrApp      l e1 e2 -> LeftArrApp      (f l) (fmap f e1) (fmap f e2)
-          RightArrApp     l e1 e2 -> RightArrApp     (f l) (fmap f e1) (fmap f e2)
-          LeftArrHighApp  l e1 e2 -> LeftArrHighApp  (f l) (fmap f e1) (fmap f e2)
-          RightArrHighApp l e1 e2 -> RightArrHighApp (f l) (fmap f e1) (fmap f e2)
-
-
-
-instance Functor PFieldUpdate where
-    fmap f (FieldUpdate l qn e) = FieldUpdate (f l) (fmap f qn) (fmap f e)
-    fmap f (FieldPun l n)       = FieldPun (f l) (fmap f n)
-    fmap f (FieldWildcard l)    = FieldWildcard (f l)
-
-instance Annotated PFieldUpdate where
-    ann (FieldUpdate l qn e) = l
-    ann (FieldPun l n)       = l
-    ann (FieldWildcard l)    = l
-    amap f (FieldUpdate l qn e) = FieldUpdate (f l) qn e
-    amap f (FieldPun l n)       = FieldPun (f l) n
-    amap f (FieldWildcard l)    = FieldWildcard (f l)
-
-instance Functor ParseXAttr where
-    fmap f (XAttr l xn e) = XAttr (f l) (fmap f xn) (fmap f e)
-
-instance Annotated ParseXAttr where
-    ann (XAttr l _ _) = l
-    amap f (XAttr l xn e) = XAttr (f l) xn e
-
-p_unit_con :: l -> PExp l
-p_unit_con l         = Con l (unit_con_name l)
-
-p_tuple_con :: l -> Boxed -> Int -> PExp l
-p_tuple_con l b i       = Con l (tuple_con_name l b i)
-
-p_unboxed_singleton_con :: l -> PExp l
-p_unboxed_singleton_con l = Con l (unboxed_singleton_con_name l)
-
-data PContext l
-    = CxSingle l (PAsst l)
-    | CxTuple  l [PAsst l]
-    | CxParen  l (PContext l)
-    | CxEmpty  l
- deriving (Eq, Show)
-
-instance Functor PContext where
-  fmap f (CxSingle l asst) = CxSingle (f l) (fmap f asst)
-  fmap f (CxTuple l assts) = CxTuple (f l) (map (fmap f) assts)
-  fmap f (CxParen l ctxt)  = CxParen (f l) (fmap f ctxt)
-  fmap f (CxEmpty l)       = CxEmpty (f l)
-
-instance Annotated PContext where
-  ann (CxSingle l asst ) = l
-  ann (CxTuple  l assts) = l
-  ann (CxParen  l ctxt ) = l
-  ann (CxEmpty  l)       = l
-  amap f (CxSingle l asst ) = CxSingle (f l) asst
-  amap f (CxTuple  l assts) = CxTuple  (f l) assts
-  amap f (CxParen  l ctxt ) = CxParen  (f l) ctxt
-  amap f (CxEmpty l) = CxEmpty (f l)
-
-data PType l
-     = TyForall l
-        (Maybe [TyVarBind l])
-        (Maybe (PContext l))
-        (PType l)
-     | TyFun   l (PType l) (PType l)            -- ^ function type
-     | TyTuple l Boxed     [PType l]            -- ^ tuple type, possibly boxed
-     | TyList  l (PType l)                      -- ^ list syntax, e.g. [a], as opposed to [] a
-     | TyApp   l (PType l) (PType l)            -- ^ application of a type constructor
-     | TyVar   l (Name l)                       -- ^ type variable
-     | TyCon   l (QName l)                      -- ^ named type or type constructor
-     | TyParen l (PType l)                      -- ^ type surrounded by parentheses
-     | TyPred  l (PAsst l)                      -- ^ assertion of an implicit parameter
-     | TyInfix l (PType l) (QName l) (PType l)  -- ^ infix type constructor
-     | TyKind  l (PType l) (Kind l)             -- ^ type with explicit kind signature
-  deriving (Eq, Show)
-
-instance Functor PType where
-    fmap f t = case t of
-      TyForall l mtvs mcx t         -> TyForall (f l) (fmap (map (fmap f)) mtvs) (fmap (fmap f) mcx) (fmap f t)
-      TyFun   l t1 t2               -> TyFun (f l) (fmap f t1) (fmap f t2)
-      TyTuple l b ts                -> TyTuple (f l) b (map (fmap f) ts)
-      TyList  l t                   -> TyList (f l) (fmap f t)
-      TyApp   l t1 t2               -> TyApp (f l) (fmap f t1) (fmap f t2)
-      TyVar   l n                   -> TyVar (f l) (fmap f n)
-      TyCon   l qn                  -> TyCon (f l) (fmap f qn)
-      TyParen l t                   -> TyParen (f l) (fmap f t)
-      TyPred  l asst                -> TyPred (f l) (fmap f asst)
-      TyInfix l ta qn tb            -> TyInfix (f l) (fmap f ta) (fmap f qn) (fmap f tb)
-      TyKind  l t k                 -> TyKind (f l) (fmap f t) (fmap f k)
-
-instance Annotated PType where
-    ann t = case t of
-      TyForall l mtvs cx t          -> l
-      TyFun   l t1 t2               -> l
-      TyTuple l b ts                -> l
-      TyList  l t                   -> l
-      TyApp   l t1 t2               -> l
-      TyVar   l n                   -> l
-      TyCon   l qn                  -> l
-      TyParen l t                   -> l
-      TyInfix l ta qn tb            -> l
-      TyKind  l t k                 -> l
-    amap f t = case t of
-      TyForall l mtvs mcx t         -> TyForall (f l) mtvs mcx t
-      TyFun   l t1 t2               -> TyFun (f l) t1 t2
-      TyTuple l b ts                -> TyTuple (f l) b ts
-      TyList  l t                   -> TyList (f l) t
-      TyApp   l t1 t2               -> TyApp (f l) t1 t2
-      TyVar   l n                   -> TyVar (f l) n
-      TyCon   l qn                  -> TyCon (f l) qn
-      TyParen l t                   -> TyParen (f l) t
-      TyInfix l ta qn tb            -> TyInfix (f l) ta qn tb
-      TyKind  l t k                 -> TyKind (f l) t k
-
-data PAsst l
-    = ClassA l (QName l) [PType l]
-    | InfixA l (PType l) (QName l) (PType l)
-    | IParam l (IPName l) (PType l)
-    | EqualP l (PType l)  (PType l)
-  deriving (Eq, Show)
-
-instance Functor PAsst where
-    fmap f asst = case asst of
-        ClassA l qn ts      -> ClassA (f l) (fmap f qn) (map (fmap f) ts)
-        InfixA l ta qn tb   -> InfixA (f l) (fmap f ta) (fmap f qn) (fmap f tb)
-        IParam l ipn t      -> IParam (f l) (fmap f ipn) (fmap f t)
-        EqualP l t1 t2      -> EqualP (f l) (fmap f t1) (fmap f t2)
-
-instance Annotated PAsst where
-    ann asst = case asst of
-        ClassA l qn ts      -> l
-        InfixA l ta qn tb   -> l
-        IParam l ipn t      -> l
-        EqualP l t1 t2      -> l
-    amap f asst = case asst of
-        ClassA l qn ts      -> ClassA (f l) qn ts
-        InfixA l ta qn tb   -> InfixA (f l) ta qn tb
-        IParam l ipn t      -> IParam (f l) ipn t
-        EqualP l t1 t2      -> EqualP (f l) t1 t2
-
-
-unit_tycon, fun_tycon, list_tycon, unboxed_singleton_tycon :: l -> PType l
-unit_tycon              l = TyCon l (unit_tycon_name l)
-fun_tycon               l = TyCon l (fun_tycon_name l)
-list_tycon              l = TyCon l (list_tycon_name l)
-unboxed_singleton_tycon l = TyCon l (unboxed_singleton_tycon_name l)
-
-tuple_tycon :: l -> Boxed -> Int -> PType l
-tuple_tycon l b i         = TyCon l (tuple_tycon_name l b i)
+{-# OPTIONS_HADDOCK hide #-}+module Language.Haskell.Exts.ParseSyntax where++import Language.Haskell.Exts.Annotated.Syntax hiding ( Type(..), Asst(..), Exp(..), FieldUpdate(..), XAttr(..), Context(..) )+import qualified Language.Haskell.Exts.Annotated.Syntax as S ( Type(..), Asst(..), Exp(..), FieldUpdate(..), XAttr(..), Context(..) )++---------------------------------------+-- Expressions as we parse them (and patterns, and regular patterns)++data PExp l+    = Var l (QName l)                       -- ^ variable+    | IPVar l (IPName l)                    -- ^ implicit parameter variable+    | Con l (QName l)                       -- ^ data constructor+    | Lit l (Literal l)                     -- ^ literal constant+    | InfixApp l (PExp l) (QOp l) (PExp l)  -- ^ infix application+    | App l (PExp l) (PExp l)               -- ^ ordinary application+    | NegApp l (PExp l)                     -- ^ negation expression @-@ /exp/+    | Lambda l [Pat l] (PExp l)             -- ^ lambda expression+    | Let l (Binds l) (PExp l)              -- ^ local declarations with @let@+    | If l (PExp l) (PExp l) (PExp l)       -- ^ @if@ /exp/ @then@ /exp/ @else@ /exp/+    | Case l (PExp l) [Alt l]               -- ^ @case@ /exp/ @of@ /alts/+    | Do l [Stmt l]                         -- ^ @do@-expression:+                                            --   the last statement in the list+                                            --   should be an expression.+    | MDo l [Stmt l]                        -- ^ @mdo@-expression+--    | Tuple [PExp]                        -- ^ tuple expression+    | TupleSection l Boxed [Maybe (PExp l)] -- ^ tuple section expression, e.g. @(,,3)@+    | List l [PExp l]                       -- ^ list expression+    | Paren l (PExp l)                      -- ^ parenthesized expression+--     RightSection QOp PExp                -- ^ right section @(@/qop/ /exp/@)@+    | RecConstr l (QName l) [PFieldUpdate l]+                                            -- ^ record construction expression+    | RecUpdate l (PExp l) [PFieldUpdate l]+                                            -- ^ record update expression+    | EnumFrom l (PExp l)                   -- ^ unbounded arithmetic sequence,+                                            --   incrementing by 1+    | EnumFromTo l (PExp l) (PExp l)        -- ^ bounded arithmetic sequence,+                                            --   incrementing by 1+    | EnumFromThen l (PExp l) (PExp l)      -- ^ unbounded arithmetic sequence,+                                            --   with first two elements given+    | EnumFromThenTo l (PExp l) (PExp l) (PExp l)+                                            -- ^ bounded arithmetic sequence,+                                            --   with first two elements given+    | ParComp l (PExp l) [[QualStmt l]]     -- ^ parallel list comprehension+    | ExpTypeSig l (PExp l) (S.Type l)      -- ^ expression type signature+    | AsPat l (Name l) (PExp l)             -- ^ patterns only+    | WildCard l                            -- ^ patterns only+    | IrrPat l (PExp l)                     -- ^ patterns only++-- Post-ops for parsing left sections and regular patterns. Not to be left in the final tree.+    | PostOp l (PExp l) (QOp l)             -- ^ post-ops+    | PreOp l (QOp l) (PExp l)              -- ^ pre-ops++-- View patterns+    | ViewPat l (PExp l) (PExp l)           -- ^ patterns only++-- HaRP+    | SeqRP l [PExp l]                      -- ^ regular patterns only+    | GuardRP l (PExp l) [Stmt l]           -- ^ regular patterns only+    | EitherRP l (PExp l) (PExp l)          -- ^ regular patterns only+    | CAsRP l (Name l) (PExp l)             -- ^ regular patterns only++-- Template Haskell+    | VarQuote l (QName l)                  -- ^ 'x+    | TypQuote l (QName l)                  -- ^ ''T+    | BracketExp l (Bracket l)+    | SpliceExp l (Splice l)+    | QuasiQuote l String String            -- ^ [$...|...]++-- Hsx+    | XTag  l (XName l) [ParseXAttr l] (Maybe (PExp l)) [PExp l]+                                            -- ^ <Name>...</Name>+    | XETag l (XName l) [ParseXAttr l] (Maybe (PExp l))+                                            -- ^ <Name />+    | XPcdata l String                      -- ^ PCDATA+    | XExpTag l (PExp l)                    -- ^ <% ... %>+    | XChildTag l [PExp l]                  -- ^ <%> ... </%>+    | XRPats l [PExp l]                     -- ^ <[ ... ]>++-- Pragmas+    | CorePragma l      String  (PExp l)    -- ^ {-# CORE #-} pragma+    | SCCPragma  l      String  (PExp l)    -- ^ {-# SCC #-} pragma+    | GenPragma  l      String (Int, Int) (Int, Int) (PExp l)+                                            -- ^ {-# GENERATED ... #-} pragma++-- Generics+    | ExplTypeArg l (QName l) (S.Type l)    -- ^ f {| Int |} x = ...++-- Bang Patterns+    | BangPat l (PExp l)                    -- ^ f !a = ...++-- Arrows+    | Proc l (Pat l) (PExp l)               -- ^ proc p -> do+    | LeftArrApp      l (PExp l) (PExp l)   -- ^ e -< e+    | RightArrApp     l (PExp l) (PExp l)   -- ^ e >- e+    | LeftArrHighApp  l (PExp l) (PExp l)   -- ^ e -<< e+    | RightArrHighApp l (PExp l) (PExp l)   -- ^ e >>- e+   deriving (Eq,Show)++data PFieldUpdate l+    = FieldUpdate l (QName l) (PExp l)+    | FieldPun l (Name l)+    | FieldWildcard l+  deriving (Eq,Show)++data ParseXAttr l = XAttr l (XName l) (PExp l)+  deriving (Eq,Show)++instance Annotated PExp where+    ann e = case e of+        Var l qn        -> l+        IPVar l ipn     -> l+        Con l qn        -> l+        Lit l lit       -> l+        InfixApp l e1 qop e2    -> l+        App l e1 e2     -> l+        NegApp l e      -> l+        Lambda l ps e   -> l+        Let l bs e      -> l+        If l ec et ee   -> l+        Case l e alts   -> l+        Do l ss         -> l+        MDo l ss        -> l+        TupleSection l bx mes -> l+        List l es       -> l+        Paren l e       -> l+        RecConstr l qn fups     -> l+        RecUpdate l e  fups     -> l+        EnumFrom l e            -> l+        EnumFromTo l ef et      -> l+        EnumFromThen l ef et    -> l+        EnumFromThenTo l ef eth eto -> l+        ParComp  l e qsss       -> l+        ExpTypeSig l e t        -> l+        AsPat l n e             -> l+        WildCard l              -> l+        IrrPat l e              -> l+        PostOp l e op           -> l+        PreOp l op e            -> l+        ViewPat l e1 e2         -> l+        SeqRP l es              -> l+        GuardRP l e ss          -> l+        EitherRP l e1 e2        -> l+        CAsRP l n e             -> l++        VarQuote l qn           -> l+        TypQuote l qn           -> l+        BracketExp l br         -> l+        SpliceExp l sp          -> l+        QuasiQuote l sn se      -> l++        XTag  l xn xas me es    -> l+        XETag l xn xas me       -> l+        XPcdata l s             -> l+        XExpTag l e             -> l+        XChildTag l es          -> l+        XRPats l es             -> l++        CorePragma l s e   -> l+        SCCPragma  l s e   -> l+        GenPragma  l s n12 n34 e -> l++        ExplTypeArg l qn t      -> l+        BangPat l e             -> l++        Proc            l p e   -> l+        LeftArrApp      l e1 e2 -> l+        RightArrApp     l e1 e2 -> l+        LeftArrHighApp  l e1 e2 -> l+        RightArrHighApp l e1 e2 -> l++    amap f e = case e of+        Var l qn                -> Var   (f l) qn+        IPVar l ipn             -> IPVar (f l) ipn+        Con l qn                -> Con   (f l) qn+        Lit l lit               -> Lit   (f l) lit+        InfixApp l e1 qop e2    -> InfixApp (f l) e1 qop e2+        App l e1 e2             -> App (f l) e1 e2+        NegApp l e              -> NegApp (f l) e+        Lambda l ps e           -> Lambda (f l) ps e+        Let l bs e              -> Let (f l) bs e+        If l ec et ee           -> If (f l) ec et ee+        Case l e alts           -> Case (f l) e alts+        Do l ss                 -> Do (f l) ss+        MDo l ss                -> MDo (f l) ss+        TupleSection l bx mes   -> TupleSection (f l) bx mes+        List l es               -> List (f l) es+        Paren l e               -> Paren (f l) e+        RecConstr l qn fups     -> RecConstr (f l) qn fups+        RecUpdate l e  fups     -> RecUpdate (f l) e  fups+        EnumFrom l e            -> EnumFrom (f l) e+        EnumFromTo l ef et      -> EnumFromTo (f l) ef et+        EnumFromThen l ef et    -> EnumFromThen (f l) ef et+        EnumFromThenTo l ef eth eto -> EnumFromThenTo (f l) ef eth eto+        ParComp  l e qsss       -> ParComp  (f l) e qsss+        ExpTypeSig l e t        -> ExpTypeSig (f l) e t++        AsPat l n e             -> AsPat (f l) n e+        WildCard l              -> WildCard (f l)+        IrrPat l e              -> IrrPat (f l) e+        PostOp l e op           -> PostOp (f l) e op+        PreOp l op e            -> PreOp (f l) op e+        ViewPat l e1 e2         -> ViewPat (f l) e1 e2+        SeqRP l es              -> SeqRP (f l) es+        GuardRP l e ss          -> GuardRP (f l) e ss+        EitherRP l e1 e2        -> EitherRP (f l) e1 e2+        CAsRP l n e             -> CAsRP (f l) n e+        ExplTypeArg l n t       -> ExplTypeArg (f l) n t+        BangPat l e             -> BangPat (f l) e++        VarQuote l qn           -> VarQuote (f l) qn+        TypQuote l qn           -> TypQuote (f l) qn+        BracketExp l br         -> BracketExp (f l) br+        SpliceExp l sp          -> SpliceExp (f l) sp+        QuasiQuote l sn se      -> QuasiQuote (f l) sn se++        XTag  l xn xas me es    -> XTag  (f l) xn xas me es+        XETag l xn xas me       -> XETag (f l) xn xas me+        XPcdata l s             -> XPcdata (f l) s+        XExpTag l e             -> XExpTag (f l) e+        XChildTag l es          -> XChildTag (f l) es+        XRPats l es             -> XRPats (f l) es++        CorePragma l s e        -> CorePragma (f l) s e+        SCCPragma  l s e        -> SCCPragma  (f l) s e+        GenPragma  l s n12 n34 e -> GenPragma  (f l) s n12 n34 e++        Proc            l p e   -> Proc            (f l) p e+        LeftArrApp      l e1 e2 -> LeftArrApp      (f l) e1 e2+        RightArrApp     l e1 e2 -> RightArrApp     (f l) e1 e2+        LeftArrHighApp  l e1 e2 -> LeftArrHighApp  (f l) e1 e2+        RightArrHighApp l e1 e2 -> RightArrHighApp (f l) e1 e2++instance Functor PExp where+      fmap f e = case e of+          Var l qn                -> Var   (f l) (fmap f qn)+          IPVar l ipn             -> IPVar (f l) (fmap f ipn)+          Con l qn                -> Con   (f l) (fmap f qn)+          Lit l lit               -> Lit   (f l) (fmap f lit)+          InfixApp l e1 qop e2    -> InfixApp (f l) (fmap f e1) (fmap f qop) (fmap f e2)+          App l e1 e2             -> App (f l) (fmap f e1) (fmap f e2)+          NegApp l e              -> NegApp (f l) (fmap f e)+          Lambda l ps e           -> Lambda (f l) (map (fmap f) ps) (fmap f e)+          Let l bs e              -> Let (f l) (fmap f bs) (fmap f e)+          If l ec et ee           -> If (f l) (fmap f ec) (fmap f et) (fmap f ee)+          Case l e alts           -> Case (f l) (fmap f e) (map (fmap f) alts)+          Do l ss                 -> Do (f l) (map (fmap f) ss)+          MDo l ss                -> MDo (f l) (map (fmap f) ss)+          TupleSection l bx mes   -> TupleSection (f l) bx (map (fmap (fmap f)) mes)+          List l es               -> List (f l) (map (fmap f) es)+          Paren l e               -> Paren (f l) (fmap f e)+          RecConstr l qn fups     -> RecConstr (f l) (fmap f qn) (map (fmap f) fups)+          RecUpdate l e  fups     -> RecUpdate (f l) (fmap f e)  (map (fmap f) fups)+          EnumFrom l e            -> EnumFrom (f l) (fmap f e)+          EnumFromTo l ef et      -> EnumFromTo (f l) (fmap f ef) (fmap f et)+          EnumFromThen l ef et    -> EnumFromThen (f l) (fmap f ef) (fmap f et)+          EnumFromThenTo l ef eth eto -> EnumFromThenTo (f l) (fmap f ef) (fmap f eth) (fmap f eto)+          ParComp  l e qsss       -> ParComp  (f l) (fmap f e) (map (map (fmap f)) qsss)+          ExpTypeSig l e t        -> ExpTypeSig (f l) (fmap f e) (fmap f t)++          AsPat l n e             -> AsPat (f l) (fmap f n) (fmap f e)+          WildCard l              -> WildCard (f l)+          IrrPat l e              -> IrrPat (f l) (fmap f e)+          PostOp l e op           -> PostOp (f l) (fmap f e) (fmap f op)+          PreOp l op e            -> PreOp (f l) (fmap f op) (fmap f e)+          ViewPat l e1 e2         -> ViewPat (f l) (fmap f e1) (fmap f e2)+          SeqRP l es              -> SeqRP (f l) (map (fmap f) es)+          GuardRP l e ss          -> GuardRP (f l) (fmap f e) (map (fmap f) ss)+          EitherRP l e1 e2        -> EitherRP (f l) (fmap f e1) (fmap f e2)+          CAsRP l n e             -> CAsRP (f l) (fmap f n) (fmap f e)+          ExplTypeArg l n t       -> ExplTypeArg (f l) (fmap f n) (fmap f t)+          BangPat l e             -> BangPat (f l) (fmap f e)++          VarQuote l qn           -> VarQuote (f l) (fmap f qn)+          TypQuote l qn           -> TypQuote (f l) (fmap f qn)+          BracketExp l br         -> BracketExp (f l) (fmap f br)+          SpliceExp l sp          -> SpliceExp (f l) (fmap f sp)+          QuasiQuote l sn se      -> QuasiQuote (f l) sn se++          XTag  l xn xas me es    -> XTag  (f l) (fmap f xn) (map (fmap f) xas) (fmap (fmap f) me) (map (fmap f) es)+          XETag l xn xas me       -> XETag (f l) (fmap f xn) (map (fmap f) xas) (fmap (fmap f) me)+          XPcdata l s             -> XPcdata (f l) s+          XExpTag l e             -> XExpTag (f l) (fmap f e)+          XChildTag l es          -> XChildTag (f l) (map (fmap f) es)+          XRPats l es             -> XRPats (f l) (map (fmap f) es)++          CorePragma l s e        -> CorePragma (f l) s (fmap f e)+          SCCPragma  l s e        -> SCCPragma  (f l) s (fmap f e)+          GenPragma  l s n12 n34 e -> GenPragma  (f l) s n12 n34 (fmap f e)++          Proc            l p e   -> Proc            (f l) (fmap f p) (fmap f e)+          LeftArrApp      l e1 e2 -> LeftArrApp      (f l) (fmap f e1) (fmap f e2)+          RightArrApp     l e1 e2 -> RightArrApp     (f l) (fmap f e1) (fmap f e2)+          LeftArrHighApp  l e1 e2 -> LeftArrHighApp  (f l) (fmap f e1) (fmap f e2)+          RightArrHighApp l e1 e2 -> RightArrHighApp (f l) (fmap f e1) (fmap f e2)++++instance Functor PFieldUpdate where+    fmap f (FieldUpdate l qn e) = FieldUpdate (f l) (fmap f qn) (fmap f e)+    fmap f (FieldPun l n)       = FieldPun (f l) (fmap f n)+    fmap f (FieldWildcard l)    = FieldWildcard (f l)++instance Annotated PFieldUpdate where+    ann (FieldUpdate l qn e) = l+    ann (FieldPun l n)       = l+    ann (FieldWildcard l)    = l+    amap f (FieldUpdate l qn e) = FieldUpdate (f l) qn e+    amap f (FieldPun l n)       = FieldPun (f l) n+    amap f (FieldWildcard l)    = FieldWildcard (f l)++instance Functor ParseXAttr where+    fmap f (XAttr l xn e) = XAttr (f l) (fmap f xn) (fmap f e)++instance Annotated ParseXAttr where+    ann (XAttr l _ _) = l+    amap f (XAttr l xn e) = XAttr (f l) xn e++p_unit_con :: l -> PExp l+p_unit_con l         = Con l (unit_con_name l)++p_tuple_con :: l -> Boxed -> Int -> PExp l+p_tuple_con l b i       = Con l (tuple_con_name l b i)++p_unboxed_singleton_con :: l -> PExp l+p_unboxed_singleton_con l = Con l (unboxed_singleton_con_name l)++data PContext l+    = CxSingle l (PAsst l)+    | CxTuple  l [PAsst l]+    | CxParen  l (PContext l)+    | CxEmpty  l+ deriving (Eq, Show)++instance Functor PContext where+  fmap f (CxSingle l asst) = CxSingle (f l) (fmap f asst)+  fmap f (CxTuple l assts) = CxTuple (f l) (map (fmap f) assts)+  fmap f (CxParen l ctxt)  = CxParen (f l) (fmap f ctxt)+  fmap f (CxEmpty l)       = CxEmpty (f l)++instance Annotated PContext where+  ann (CxSingle l asst ) = l+  ann (CxTuple  l assts) = l+  ann (CxParen  l ctxt ) = l+  ann (CxEmpty  l)       = l+  amap f (CxSingle l asst ) = CxSingle (f l) asst+  amap f (CxTuple  l assts) = CxTuple  (f l) assts+  amap f (CxParen  l ctxt ) = CxParen  (f l) ctxt+  amap f (CxEmpty l) = CxEmpty (f l)++data PType l+     = TyForall l+        (Maybe [TyVarBind l])+        (Maybe (PContext l))+        (PType l)+     | TyFun   l (PType l) (PType l)            -- ^ function type+     | TyTuple l Boxed     [PType l]            -- ^ tuple type, possibly boxed+     | TyList  l (PType l)                      -- ^ list syntax, e.g. [a], as opposed to [] a+     | TyApp   l (PType l) (PType l)            -- ^ application of a type constructor+     | TyVar   l (Name l)                       -- ^ type variable+     | TyCon   l (QName l)                      -- ^ named type or type constructor+     | TyParen l (PType l)                      -- ^ type surrounded by parentheses+     | TyPred  l (PAsst l)                      -- ^ assertion of an implicit parameter+     | TyInfix l (PType l) (QName l) (PType l)  -- ^ infix type constructor+     | TyKind  l (PType l) (Kind l)             -- ^ type with explicit kind signature+  deriving (Eq, Show)++instance Functor PType where+    fmap f t = case t of+      TyForall l mtvs mcx t         -> TyForall (f l) (fmap (map (fmap f)) mtvs) (fmap (fmap f) mcx) (fmap f t)+      TyFun   l t1 t2               -> TyFun (f l) (fmap f t1) (fmap f t2)+      TyTuple l b ts                -> TyTuple (f l) b (map (fmap f) ts)+      TyList  l t                   -> TyList (f l) (fmap f t)+      TyApp   l t1 t2               -> TyApp (f l) (fmap f t1) (fmap f t2)+      TyVar   l n                   -> TyVar (f l) (fmap f n)+      TyCon   l qn                  -> TyCon (f l) (fmap f qn)+      TyParen l t                   -> TyParen (f l) (fmap f t)+      TyPred  l asst                -> TyPred (f l) (fmap f asst)+      TyInfix l ta qn tb            -> TyInfix (f l) (fmap f ta) (fmap f qn) (fmap f tb)+      TyKind  l t k                 -> TyKind (f l) (fmap f t) (fmap f k)++instance Annotated PType where+    ann t = case t of+      TyForall l mtvs cx t          -> l+      TyFun   l t1 t2               -> l+      TyTuple l b ts                -> l+      TyList  l t                   -> l+      TyApp   l t1 t2               -> l+      TyVar   l n                   -> l+      TyCon   l qn                  -> l+      TyParen l t                   -> l+      TyInfix l ta qn tb            -> l+      TyKind  l t k                 -> l+    amap f t = case t of+      TyForall l mtvs mcx t         -> TyForall (f l) mtvs mcx t+      TyFun   l t1 t2               -> TyFun (f l) t1 t2+      TyTuple l b ts                -> TyTuple (f l) b ts+      TyList  l t                   -> TyList (f l) t+      TyApp   l t1 t2               -> TyApp (f l) t1 t2+      TyVar   l n                   -> TyVar (f l) n+      TyCon   l qn                  -> TyCon (f l) qn+      TyParen l t                   -> TyParen (f l) t+      TyInfix l ta qn tb            -> TyInfix (f l) ta qn tb+      TyKind  l t k                 -> TyKind (f l) t k++data PAsst l+    = ClassA l (QName l) [PType l]+    | InfixA l (PType l) (QName l) (PType l)+    | IParam l (IPName l) (PType l)+    | EqualP l (PType l)  (PType l)+  deriving (Eq, Show)++instance Functor PAsst where+    fmap f asst = case asst of+        ClassA l qn ts      -> ClassA (f l) (fmap f qn) (map (fmap f) ts)+        InfixA l ta qn tb   -> InfixA (f l) (fmap f ta) (fmap f qn) (fmap f tb)+        IParam l ipn t      -> IParam (f l) (fmap f ipn) (fmap f t)+        EqualP l t1 t2      -> EqualP (f l) (fmap f t1) (fmap f t2)++instance Annotated PAsst where+    ann asst = case asst of+        ClassA l qn ts      -> l+        InfixA l ta qn tb   -> l+        IParam l ipn t      -> l+        EqualP l t1 t2      -> l+    amap f asst = case asst of+        ClassA l qn ts      -> ClassA (f l) qn ts+        InfixA l ta qn tb   -> InfixA (f l) ta qn tb+        IParam l ipn t      -> IParam (f l) ipn t+        EqualP l t1 t2      -> EqualP (f l) t1 t2+++unit_tycon, fun_tycon, list_tycon, unboxed_singleton_tycon :: l -> PType l+unit_tycon              l = TyCon l (unit_tycon_name l)+fun_tycon               l = TyCon l (fun_tycon_name l)+list_tycon              l = TyCon l (list_tycon_name l)+unboxed_singleton_tycon l = TyCon l (unboxed_singleton_tycon_name l)++tuple_tycon :: l -> Boxed -> Int -> PType l+tuple_tycon l b i         = TyCon l (tuple_tycon_name l b i)
src/Language/Haskell/Exts/ParseUtils.hs view
@@ -137,9 +137,9 @@ checkAssertion (TyPred _ p@(EqualP _ _ _)) = return p checkAssertion t = checkAssertion' id [] t     where   -- class assertions must have at least one argument-            checkAssertion' fl ts@(_:xs) (TyCon l c) = do-                when (not $ null xs) $ checkEnabled MultiParamTypeClasses-                when (isSymbol c)    $ checkEnabled TypeOperators+            checkAssertion' fl ts (TyCon l c) = do+                when (length ts /= 1) $ checkEnabled MultiParamTypeClasses+                when (isSymbol c)     $ checkEnabled TypeOperators                 return $ ClassA (fl l) c ts             checkAssertion' fl ts (TyApp l a t) = do                 -- no check on t at this stage@@ -338,10 +338,10 @@                             return (PNPlusK (loc <** [pp,kp]) n k)                         _ -> patFail ""             _ -> patFail ""-    TupleSection l mes    ->+    TupleSection l bx mes    ->             if not (any ((==) Nothing) mes)              then do ps <- mapM (\e -> checkPat e []) (map fromJust mes)-                     return (PTuple l ps)+                     return (PTuple l bx ps)              else fail "Illegal tuple section in pattern"      List l es      -> do@@ -537,6 +537,8 @@     Lit l lit             -> return $ S.Lit l lit     InfixApp l e1 op e2   -> check2Exprs e1 e2 (flip (S.InfixApp l) op)     App l e1 e2           -> check2Exprs e1 e2 (S.App l)+    NegApp l (Lit _ (PrimWord _ i _))+                          -> fail $ "Parse error: negative primitive word literal: " ++ prettyPrint e     NegApp l e            -> check1Expr e (S.NegApp l)     Lambda loc ps e       -> check1Expr e (S.Lambda loc ps)     Let l bs e            -> check1Expr e (S.Let l bs)@@ -546,11 +548,11 @@                      return (S.Case l e alts)     Do l stmts            -> checkDo stmts >> return (S.Do l stmts)     MDo l stmts           -> checkDo stmts >> return (S.MDo l stmts)-    TupleSection l mes -> if not (any ((==) Nothing) mes)-                           then checkManyExprs (map fromJust mes) (S.Tuple l)-                           else do checkEnabled TupleSections-                                   mes' <- mapM mCheckExpr mes-                                   return $ S.TupleSection l mes'+    TupleSection l bx mes -> if not (any ((==) Nothing) mes)+                             then checkManyExprs (map fromJust mes) (S.Tuple l bx)+                             else do checkEnabled TupleSections+                                     mes' <- mapM mCheckExpr mes+                                     return $ S.TupleSection l bx mes'       List l es         -> checkManyExprs es (S.List l)@@ -693,7 +695,7 @@             case optsig of -- only pattern bindings can have signatures                 Nothing -> return (FunBind l $                             if b then [Match l' f ps rhs whereBinds]-                                 else let (a:bs) = ps +                                 else let (a:bs) = ps                                        in [InfixMatch l' a f bs rhs whereBinds])                 Just _  -> fail "Cannot give an explicit type signature to a function binding"      Nothing     -> do@@ -714,9 +716,9 @@ isFunLhs (App _ (Var _ (UnQual _ f)) e) es = return $ Just (f, e:es, True, []) isFunLhs (App _ f e) es = isFunLhs f (e:es) isFunLhs (Var _ (UnQual _ f)) es@(_:_) = return $ Just (f, es, True, [])-isFunLhs (Paren l f) es@(_:_) = do mlhs <- isFunLhs f es +isFunLhs (Paren l f) es@(_:_) = do mlhs <- isFunLhs f es                                    case mlhs of-                                    Just (f,es,b,pts) -> +                                    Just (f,es,b,pts) ->                                        let [x,y] = srcInfoPoints l                                         in return $ Just (f,es,b,x:pts++[y])                                     _ -> return Nothing
src/Language/Haskell/Exts/Parser.hs view
@@ -1,189 +1,189 @@------------------------------------------------------------------------------
--- |
--- Module      :  Language.Haskell.Exts.Parser
--- Copyright   :  (c) The GHC Team, 1997-2000
---                (c) Niklas Broberg, 2004-2012
--- License     :  BSD-style (see the file LICENSE.txt)
---
--- Maintainer  :  Niklas Broberg, niklas.broberg@chalmers.se
--- Stability   :  stable
--- Portability :  portable
---
--- Parser for Haskell with extensions.
---
------------------------------------------------------------------------------
-
-module Language.Haskell.Exts.Parser
-            (
-                -- * General parsing
-                Parseable(..),
-                ParseMode(..), defaultParseMode, ParseResult(..), fromParseResult,
-                -- * Parsing of specific AST elements
-                -- ** Modules
-                parseModule, parseModuleWithMode, parseModuleWithComments,
-                -- ** Expressions
-                parseExp, parseExpWithMode, parseExpWithComments,
-                -- ** Statements
-                parseStmt, parseStmtWithMode, parseStmtWithComments,
-                -- ** Patterns
-                parsePat, parsePatWithMode, parsePatWithComments,
-                -- ** Declarations
-                parseDecl, parseDeclWithMode, parseDeclWithComments,
-                -- ** Types
-                parseType, parseTypeWithMode, parseTypeWithComments,
-                -- ** Option pragmas
-                getTopPragmas
-            ) where
-
-
-import Language.Haskell.Exts.InternalParser ( ParseMode(..), defaultParseMode, ParseResult(..), fromParseResult )
-import qualified Language.Haskell.Exts.InternalParser as P
-
-import Language.Haskell.Exts.Annotated.Syntax
-import qualified Language.Haskell.Exts.Syntax as S
-import Language.Haskell.Exts.Annotated.Simplify
-
-import Language.Haskell.Exts.SrcLoc
-import Language.Haskell.Exts.Comments
-
-getTopPragmas :: String -> ParseResult [S.ModulePragma]
-getTopPragmas = fmap (map sModulePragma) . P.getTopPragmas
-
--- | Class to reuse the parse function at many different types.
-class Parseable ast where
-  -- | Parse a string with default mode.
-  parse :: String -> ParseResult ast
-  -- | Parse a string with an explicit mode.
-  parseWithMode :: ParseMode -> String -> ParseResult ast
-  -- | Parse a string with an explicit mode, returning all comments along the AST
-  parseWithComments :: ParseMode -> String -> ParseResult (ast, [Comment])
-
-
-instance SrcInfo loc => Parseable (Module loc) where
-  parse = fmap (fmap fromSrcInfo) . P.parseModule
-  parseWithMode = (fmap (fmap fromSrcInfo) .) . P.parseModuleWithMode
-  parseWithComments md s = P.parseModuleWithComments md s >>= \(r, cs) -> return (fmap fromSrcInfo r, cs)
-
-instance SrcInfo loc => Parseable (Exp loc) where
-  parse = fmap (fmap fromSrcInfo) . P.parseExp
-  parseWithMode = (fmap (fmap fromSrcInfo) .) . P.parseExpWithMode
-  parseWithComments md s = P.parseExpWithComments md s >>= \(r, cs) -> return (fmap fromSrcInfo r, cs)
-
-instance SrcInfo loc => Parseable (Pat loc) where
-  parse = fmap (fmap fromSrcInfo) . P.parsePat
-  parseWithMode = (fmap (fmap fromSrcInfo) .) . P.parsePatWithMode
-  parseWithComments md s = P.parsePatWithComments md s >>= \(r, cs) -> return (fmap fromSrcInfo r, cs)
-
-instance SrcInfo loc => Parseable (Decl loc) where
-  parse = fmap (fmap fromSrcInfo) . P.parseDecl
-  parseWithMode = (fmap (fmap fromSrcInfo) .) . P.parseDeclWithMode
-  parseWithComments md s = P.parseDeclWithComments md s >>= \(r, cs) -> return (fmap fromSrcInfo r, cs)
-
-instance SrcInfo loc => Parseable (Type loc) where
-  parse = fmap (fmap fromSrcInfo) . P.parseType
-  parseWithMode = (fmap (fmap fromSrcInfo) .) . P.parseTypeWithMode
-  parseWithComments md s = P.parseTypeWithComments md s >>= \(r, cs) -> return (fmap fromSrcInfo r, cs)
-
-instance SrcInfo loc => Parseable (Stmt loc) where
-  parse = fmap (fmap fromSrcInfo) . P.parseStmt
-  parseWithMode = (fmap (fmap fromSrcInfo) .) . P.parseStmtWithMode
-  parseWithComments md s = P.parseStmtWithComments md s >>= \(r, cs) -> return (fmap fromSrcInfo r, cs)
-
-
--- | Parse of a string, which should contain a complete Haskell module.
-parseModule :: String -> ParseResult S.Module
-parseModule = fmap sModule . P.parseModule
-
--- | Parse of a string containing a complete Haskell module, using an explicit mode.
-parseModuleWithMode :: ParseMode -> String -> ParseResult S.Module
-parseModuleWithMode = (fmap sModule .) . P.parseModuleWithMode
-
--- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.
-parseModuleWithComments :: ParseMode -> String -> ParseResult (S.Module, [Comment])
-parseModuleWithComments = (fmap (\(mod, cs) -> (sModule mod, cs)) .) . P.parseModuleWithComments
-
--- | Parse of a string containing a Haskell expression.
-parseExp :: String -> ParseResult S.Exp
-parseExp = fmap sExp . P.parseExp
-
--- | Parse of a string containing a Haskell expression, using an explicit mode.
-parseExpWithMode :: ParseMode -> String -> ParseResult S.Exp
-parseExpWithMode = (fmap sExp .) . P.parseExpWithMode
-
--- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.
-parseExpWithComments :: ParseMode -> String -> ParseResult (S.Exp, [Comment])
-parseExpWithComments = (fmap (\(e, cs) -> (sExp e, cs)) .) . P.parseExpWithComments
-
--- | Parse of a string containing a Haskell pattern.
-parsePat :: String -> ParseResult S.Pat
-parsePat = fmap sPat . P.parsePat
-
--- | Parse of a string containing a Haskell pattern, using an explicit mode.
-parsePatWithMode :: ParseMode -> String -> ParseResult S.Pat
-parsePatWithMode = (fmap sPat .) . P.parsePatWithMode
-
--- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.
-parsePatWithComments :: ParseMode -> String -> ParseResult (S.Pat, [Comment])
-parsePatWithComments = (fmap (\(p, cs) -> (sPat p, cs)) .) . P.parsePatWithComments
-
--- | Parse of a string containing a Haskell top-level declaration.
-parseDecl :: String -> ParseResult S.Decl
-parseDecl = fmap sDecl . P.parseDecl
-
--- | Parse of a string containing a Haskell top-level declaration, using an explicit mode.
-parseDeclWithMode :: ParseMode -> String -> ParseResult S.Decl
-parseDeclWithMode = (fmap sDecl .) . P.parseDeclWithMode
-
--- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.
-parseDeclWithComments :: ParseMode -> String -> ParseResult (S.Decl, [Comment])
-parseDeclWithComments = (fmap (\(decl, cs) -> (sDecl decl, cs)) .) . P.parseDeclWithComments
-
--- | Parse of a string containing a Haskell type.
-parseType :: String -> ParseResult S.Type
-parseType = fmap sType . P.parseType
-
--- | Parse of a string containing a Haskell type, using an explicit mode.
-parseTypeWithMode :: ParseMode -> String -> ParseResult S.Type
-parseTypeWithMode = (fmap sType .) . P.parseTypeWithMode
-
--- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.
-parseTypeWithComments :: ParseMode -> String -> ParseResult (S.Type, [Comment])
-parseTypeWithComments = (fmap (\(t, cs) -> (sType t, cs)) .) . P.parseTypeWithComments
-
--- | Parse of a string containing a Haskell type.
-parseStmt :: String -> ParseResult S.Stmt
-parseStmt = fmap sStmt . P.parseStmt
-
--- | Parse of a string containing a Haskell type, using an explicit mode.
-parseStmtWithMode :: ParseMode -> String -> ParseResult S.Stmt
-parseStmtWithMode = (fmap sStmt .) . P.parseStmtWithMode
-
--- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.
-parseStmtWithComments :: ParseMode -> String -> ParseResult (S.Stmt, [Comment])
-parseStmtWithComments = (fmap (\(s, cs) -> (sStmt s, cs)) .) . P.parseStmtWithComments
-
-
-instance Parseable S.Module where
-  parse = parseModule
-  parseWithMode = parseModuleWithMode
-  parseWithComments = parseModuleWithComments
-
-instance Parseable S.Exp where
-  parse = parseExp
-  parseWithMode = parseExpWithMode
-  parseWithComments = parseExpWithComments
-
-instance Parseable S.Pat where
-  parse = parsePat
-  parseWithMode = parsePatWithMode
-  parseWithComments = parsePatWithComments
-
-instance Parseable S.Decl where
-  parse = parseDecl
-  parseWithMode = parseDeclWithMode
-  parseWithComments = parseDeclWithComments
-
-instance Parseable S.Type where
-  parse = parseType
-  parseWithMode = parseTypeWithMode
-  parseWithComments = parseTypeWithComments
+-----------------------------------------------------------------------------+-- |+-- Module      :  Language.Haskell.Exts.Parser+-- Copyright   :  (c) The GHC Team, 1997-2000+--                (c) Niklas Broberg, 2004-2012+-- License     :  BSD-style (see the file LICENSE.txt)+--+-- Maintainer  :  Niklas Broberg, niklas.broberg@chalmers.se+-- Stability   :  stable+-- Portability :  portable+--+-- Parser for Haskell with extensions.+--+-----------------------------------------------------------------------------++module Language.Haskell.Exts.Parser+            (+                -- * General parsing+                Parseable(..),+                ParseMode(..), defaultParseMode, ParseResult(..), fromParseResult,+                -- * Parsing of specific AST elements+                -- ** Modules+                parseModule, parseModuleWithMode, parseModuleWithComments,+                -- ** Expressions+                parseExp, parseExpWithMode, parseExpWithComments,+                -- ** Statements+                parseStmt, parseStmtWithMode, parseStmtWithComments,+                -- ** Patterns+                parsePat, parsePatWithMode, parsePatWithComments,+                -- ** Declarations+                parseDecl, parseDeclWithMode, parseDeclWithComments,+                -- ** Types+                parseType, parseTypeWithMode, parseTypeWithComments,+                -- ** Option pragmas+                getTopPragmas+            ) where+++import Language.Haskell.Exts.InternalParser ( ParseMode(..), defaultParseMode, ParseResult(..), fromParseResult )+import qualified Language.Haskell.Exts.InternalParser as P++import Language.Haskell.Exts.Annotated.Syntax+import qualified Language.Haskell.Exts.Syntax as S+import Language.Haskell.Exts.Annotated.Simplify++import Language.Haskell.Exts.SrcLoc+import Language.Haskell.Exts.Comments++getTopPragmas :: String -> ParseResult [S.ModulePragma]+getTopPragmas = fmap (map sModulePragma) . P.getTopPragmas++-- | Class to reuse the parse function at many different types.+class Parseable ast where+  -- | Parse a string with default mode.+  parse :: String -> ParseResult ast+  -- | Parse a string with an explicit mode.+  parseWithMode :: ParseMode -> String -> ParseResult ast+  -- | Parse a string with an explicit mode, returning all comments along the AST+  parseWithComments :: ParseMode -> String -> ParseResult (ast, [Comment])+++instance SrcInfo loc => Parseable (Module loc) where+  parse = fmap (fmap fromSrcInfo) . P.parseModule+  parseWithMode = (fmap (fmap fromSrcInfo) .) . P.parseModuleWithMode+  parseWithComments md s = P.parseModuleWithComments md s >>= \(r, cs) -> return (fmap fromSrcInfo r, cs)++instance SrcInfo loc => Parseable (Exp loc) where+  parse = fmap (fmap fromSrcInfo) . P.parseExp+  parseWithMode = (fmap (fmap fromSrcInfo) .) . P.parseExpWithMode+  parseWithComments md s = P.parseExpWithComments md s >>= \(r, cs) -> return (fmap fromSrcInfo r, cs)++instance SrcInfo loc => Parseable (Pat loc) where+  parse = fmap (fmap fromSrcInfo) . P.parsePat+  parseWithMode = (fmap (fmap fromSrcInfo) .) . P.parsePatWithMode+  parseWithComments md s = P.parsePatWithComments md s >>= \(r, cs) -> return (fmap fromSrcInfo r, cs)++instance SrcInfo loc => Parseable (Decl loc) where+  parse = fmap (fmap fromSrcInfo) . P.parseDecl+  parseWithMode = (fmap (fmap fromSrcInfo) .) . P.parseDeclWithMode+  parseWithComments md s = P.parseDeclWithComments md s >>= \(r, cs) -> return (fmap fromSrcInfo r, cs)++instance SrcInfo loc => Parseable (Type loc) where+  parse = fmap (fmap fromSrcInfo) . P.parseType+  parseWithMode = (fmap (fmap fromSrcInfo) .) . P.parseTypeWithMode+  parseWithComments md s = P.parseTypeWithComments md s >>= \(r, cs) -> return (fmap fromSrcInfo r, cs)++instance SrcInfo loc => Parseable (Stmt loc) where+  parse = fmap (fmap fromSrcInfo) . P.parseStmt+  parseWithMode = (fmap (fmap fromSrcInfo) .) . P.parseStmtWithMode+  parseWithComments md s = P.parseStmtWithComments md s >>= \(r, cs) -> return (fmap fromSrcInfo r, cs)+++-- | Parse of a string, which should contain a complete Haskell module.+parseModule :: String -> ParseResult S.Module+parseModule = fmap sModule . P.parseModule++-- | Parse of a string containing a complete Haskell module, using an explicit mode.+parseModuleWithMode :: ParseMode -> String -> ParseResult S.Module+parseModuleWithMode = (fmap sModule .) . P.parseModuleWithMode++-- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.+parseModuleWithComments :: ParseMode -> String -> ParseResult (S.Module, [Comment])+parseModuleWithComments = (fmap (\(mod, cs) -> (sModule mod, cs)) .) . P.parseModuleWithComments++-- | Parse of a string containing a Haskell expression.+parseExp :: String -> ParseResult S.Exp+parseExp = fmap sExp . P.parseExp++-- | Parse of a string containing a Haskell expression, using an explicit mode.+parseExpWithMode :: ParseMode -> String -> ParseResult S.Exp+parseExpWithMode = (fmap sExp .) . P.parseExpWithMode++-- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.+parseExpWithComments :: ParseMode -> String -> ParseResult (S.Exp, [Comment])+parseExpWithComments = (fmap (\(e, cs) -> (sExp e, cs)) .) . P.parseExpWithComments++-- | Parse of a string containing a Haskell pattern.+parsePat :: String -> ParseResult S.Pat+parsePat = fmap sPat . P.parsePat++-- | Parse of a string containing a Haskell pattern, using an explicit mode.+parsePatWithMode :: ParseMode -> String -> ParseResult S.Pat+parsePatWithMode = (fmap sPat .) . P.parsePatWithMode++-- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.+parsePatWithComments :: ParseMode -> String -> ParseResult (S.Pat, [Comment])+parsePatWithComments = (fmap (\(p, cs) -> (sPat p, cs)) .) . P.parsePatWithComments++-- | Parse of a string containing a Haskell top-level declaration.+parseDecl :: String -> ParseResult S.Decl+parseDecl = fmap sDecl . P.parseDecl++-- | Parse of a string containing a Haskell top-level declaration, using an explicit mode.+parseDeclWithMode :: ParseMode -> String -> ParseResult S.Decl+parseDeclWithMode = (fmap sDecl .) . P.parseDeclWithMode++-- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.+parseDeclWithComments :: ParseMode -> String -> ParseResult (S.Decl, [Comment])+parseDeclWithComments = (fmap (\(decl, cs) -> (sDecl decl, cs)) .) . P.parseDeclWithComments++-- | Parse of a string containing a Haskell type.+parseType :: String -> ParseResult S.Type+parseType = fmap sType . P.parseType++-- | Parse of a string containing a Haskell type, using an explicit mode.+parseTypeWithMode :: ParseMode -> String -> ParseResult S.Type+parseTypeWithMode = (fmap sType .) . P.parseTypeWithMode++-- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.+parseTypeWithComments :: ParseMode -> String -> ParseResult (S.Type, [Comment])+parseTypeWithComments = (fmap (\(t, cs) -> (sType t, cs)) .) . P.parseTypeWithComments++-- | Parse of a string containing a Haskell type.+parseStmt :: String -> ParseResult S.Stmt+parseStmt = fmap sStmt . P.parseStmt++-- | Parse of a string containing a Haskell type, using an explicit mode.+parseStmtWithMode :: ParseMode -> String -> ParseResult S.Stmt+parseStmtWithMode = (fmap sStmt .) . P.parseStmtWithMode++-- | Parse of a string containing a complete Haskell module, using an explicit mode, retaining comments.+parseStmtWithComments :: ParseMode -> String -> ParseResult (S.Stmt, [Comment])+parseStmtWithComments = (fmap (\(s, cs) -> (sStmt s, cs)) .) . P.parseStmtWithComments+++instance Parseable S.Module where+  parse = parseModule+  parseWithMode = parseModuleWithMode+  parseWithComments = parseModuleWithComments++instance Parseable S.Exp where+  parse = parseExp+  parseWithMode = parseExpWithMode+  parseWithComments = parseExpWithComments++instance Parseable S.Pat where+  parse = parsePat+  parseWithMode = parsePatWithMode+  parseWithComments = parsePatWithComments++instance Parseable S.Decl where+  parse = parseDecl+  parseWithMode = parseDeclWithMode+  parseWithComments = parseDeclWithComments++instance Parseable S.Type where+  parse = parseType+  parseWithMode = parseTypeWithMode+  parseWithComments = parseTypeWithComments
src/Language/Haskell/Exts/Pretty.hs view
@@ -284,8 +284,8 @@         text "where"]  ppWarnTxt :: WarningText -> Doc-ppWarnTxt (DeprText s) = mySep [text "{-# DEPRECATED", text s, text "#-}"]-ppWarnTxt (WarnText s) = mySep [text "{-# WARNING",    text s, text "#-}"]+ppWarnTxt (DeprText s) = mySep [text "{-# DEPRECATED", text (show s), text "#-}"]+ppWarnTxt (WarnText s) = mySep [text "{-# WARNING",    text (show s), text "#-}"]  instance Pretty ModuleName where         pretty (ModuleName modName) = text modName@@ -481,10 +481,10 @@                 markLine pos $                 mySep [text "{-# INLINE_CONLIKE", pretty activ, pretty name, text "#-}"] -        pretty (SpecSig pos name types) =+        pretty (SpecSig pos activ name types) =                 blankline $                 markLine pos $-                mySep $ [text "{-# SPECIALISE", pretty name, text "::"]+                mySep $ [text "{-# SPECIALISE", pretty activ, pretty name, text "::"]                     ++ punctuate comma (map pretty types) ++ [text "#-}"]          pretty (SpecInlineSig pos inl activ name types) =@@ -587,6 +587,7 @@ instance Pretty Safety where         pretty PlayRisky        = text "unsafe"         pretty (PlaySafe b)     = text $ if b then "threadsafe" else "safe"+        pretty PlayInterruptible = text "interruptible"  instance Pretty CallConv where         pretty StdCall   = text "stdcall"@@ -628,8 +629,8 @@         myFsep $ [text "{-# OPTIONS", text s, text "#-}"]     pretty (AnnModulePragma _ ann) =         myFsep $ [text "{-# ANN", pretty ann, text "#-}"]-         + instance Pretty Tool where     pretty (UnknownTool s) = text s     pretty t               = text $ show t@@ -786,16 +787,24 @@         prettyPrec p (Case cond altList) = parensIf (p > 1) $                 myFsep [text "case", pretty cond, text "of"]                 $$$ ppBody caseIndent (map pretty altList)-        prettyPrec p (Do stmtList) = parensIf (p > 1) $ +        prettyPrec p (Do stmtList) = parensIf (p > 1) $                 text "do" $$$ ppBody doIndent (map pretty stmtList)-        prettyPrec p (MDo stmtList) = parensIf (p > 1) $ +        prettyPrec p (MDo stmtList) = parensIf (p > 1) $                 text "mdo" $$$ ppBody doIndent (map pretty stmtList)         -- Constructors & Vars         prettyPrec _ (Var name) = pretty name         prettyPrec _ (IPVar ipname) = pretty ipname         prettyPrec _ (Con name) = pretty name-        prettyPrec _ (Tuple expList) = parenList . map pretty $ expList-        prettyPrec _ (TupleSection mExpList) = parenList . map (maybePP pretty) $ mExpList+        prettyPrec _ (Tuple bxd expList) =+                let ds = map pretty expList+                in case bxd of+                       Boxed   -> parenList ds+                       Unboxed -> hashParenList ds+        prettyPrec _ (TupleSection bxd mExpList) =+                let ds = map (maybePP pretty) mExpList+                in case bxd of+                       Boxed   -> parenList ds+                       Unboxed -> hashParenList ds         -- weird stuff         prettyPrec _ (Paren e) = parens . pretty $ e         prettyPrec _ (LeftSection e op) = parens (pretty e <+> pretty op)@@ -820,9 +829,9 @@                 bracketList ([pretty e, char '|']                              ++ (punctuate comma . map pretty $ qualList))         prettyPrec _ (ParComp e qualLists) =-                bracketList (intersperse (char '|') $-                                pretty e : (punctuate comma . concatMap (map pretty) $ qualLists))-        prettyPrec p (ExpTypeSig _pos e ty) = parensIf (p > 0) $ +                bracketList (punctuate (char '|') $+                                pretty e : (map (hsep . punctuate comma . map pretty) $ qualLists))+        prettyPrec p (ExpTypeSig _pos e ty) = parensIf (p > 0) $                 myFsep [pretty e, text "::", pretty ty]         -- Template Haskell         prettyPrec _ (BracketExp b) = pretty b@@ -844,7 +853,7 @@                 myFsep $ [text "<%", pretty e, text "%>"]         prettyPrec _ (XChildTag _ cs) =                 myFsep $ text "<%>" : map pretty cs ++ [text "</%>"]-        +         -- Pragmas         prettyPrec p (CorePragma s e) = myFsep $ map text ["{-# CORE", show s, "#-}"] ++ [pretty e]         prettyPrec _ (SCCPragma  s e) = myFsep $ map text ["{-# SCC",  show s, "#-}"] ++ [pretty e]@@ -901,7 +910,11 @@                 myFsep [prettyPrec 1 a, pretty (QConOp op), prettyPrec 1 b]         prettyPrec p (PApp n ps) = parensIf (p > 1 && not (null ps)) $                 myFsep (pretty n : map (prettyPrec 2) ps)-        prettyPrec _ (PTuple ps) = parenList . map pretty $ ps+        prettyPrec _ (PTuple bxd ps) =+                let ds = map pretty ps+                in case bxd of+                       Boxed   -> parenList ds+                       Unboxed -> hashParenList ds         prettyPrec _ (PList ps) =                 bracketList . punctuate comma . map pretty $ ps         prettyPrec _ (PParen pat) = parens . pretty $ pat@@ -1534,7 +1547,11 @@         pretty (P.Var _ name) = pretty name         pretty (P.IPVar _ ipname) = pretty ipname         pretty (P.Con _ name) = pretty name-        pretty (P.TupleSection _ mExpList) = parenList . map (maybePP pretty) $ mExpList+        pretty (P.TupleSection _ bxd mExpList) =+                let ds = map (maybePP pretty) mExpList+                in case bxd of+                       Boxed   -> parenList ds+                       Unboxed -> hashParenList ds         pretty (P.Paren _ e) = parens . pretty $ e         pretty (P.RecConstr _ c fieldList) =                 pretty c <> (braceList . map pretty $ fieldList)
src/Language/Haskell/Exts/SrcLoc.hs view
@@ -1,180 +1,180 @@-{-# LANGUAGE CPP, DeriveDataTypeable #-}
------------------------------------------------------------------------------
--- |
--- Module      :  Language.Haskell.Exts.SrcLoc
--- Copyright   :  (c) Niklas Broberg 2009
--- License     :  BSD-style (see the file LICENSE.txt)
---
--- Maintainer  :  Niklas Broberg, d00nibro@chalmers.se
--- Stability   :  stable
--- Portability :  portable
---
--- This module defines various data types representing source location
--- information, of varying degree of preciseness.
---
------------------------------------------------------------------------------
-module Language.Haskell.Exts.SrcLoc where
-
-#ifdef __GLASGOW_HASKELL__
-#ifdef BASE4
-import Data.Data
-#else
-import Data.Generics (Data(..),Typeable(..))
-#endif
-#endif
-
--- | A single position in the source.
-data SrcLoc = SrcLoc
-    { srcFilename :: String
-    , srcLine :: Int
-    , srcColumn :: Int
-    }
-#ifdef __GLASGOW_HASKELL__
-  deriving (Eq,Ord,Show,Typeable,Data)
-#else
-  deriving (Eq,Ord,Show)
-#endif
-
-noLoc :: SrcLoc
-noLoc = SrcLoc "" (-1) (-1)
-
--- | A portion of the source, spanning one or more lines and zero or more columns.
-data SrcSpan = SrcSpan
-    { srcSpanFilename    :: String
-    , srcSpanStartLine   :: Int
-    , srcSpanStartColumn :: Int
-    , srcSpanEndLine     :: Int
-    , srcSpanEndColumn   :: Int
-    }
-#ifdef __GLASGOW_HASKELL__
-  deriving (Eq,Ord,Show,Typeable,Data)
-#else
-  deriving (Eq,Ord,Show)
-#endif
-
-
--- | Returns 'srcSpanStartLine' and 'srcSpanStartColumn' in a pair.
-srcSpanStart :: SrcSpan -> (Int,Int)
-srcSpanStart x = (srcSpanStartLine x, srcSpanStartColumn x)
-
--- | Returns 'srcSpanEndLine' and 'srcSpanEndColumn' in a pair.
-srcSpanEnd :: SrcSpan -> (Int,Int)
-srcSpanEnd x = (srcSpanEndLine x, srcSpanEndColumn x)
-
-
--- | Combine two locations in the source to denote a span.
-mkSrcSpan :: SrcLoc -> SrcLoc -> SrcSpan
-mkSrcSpan (SrcLoc fn sl sc) (SrcLoc _ el ec) = SrcSpan fn sl sc el ec
-
--- | Merge two source spans into a single span from the start of the first
---   to the end of the second. Assumes that the two spans relate to the
---   same source file.
-mergeSrcSpan :: SrcSpan -> SrcSpan -> SrcSpan
-mergeSrcSpan (SrcSpan fn sl1 sc1 el1 ec1) (SrcSpan _ sl2 sc2 el2 ec2) = 
-    let (sl,sc) = min (sl1,sc1) (sl2,sc2)
-        (el,ec) = max (el1,ec1) (el2,ec2)
-     in SrcSpan fn sl sc el ec
-
--- | Test if a given span starts and ends at the same location.
-isNullSpan :: SrcSpan -> Bool
-isNullSpan ss = spanSize ss == (0,0)
-{- isNullSpan ss = srcSpanStartLine ss == srcSpanEndLine ss &&
-                    srcSpanStartColumn ss >= srcSpanEndColumn ss
--}
-
-spanSize :: SrcSpan -> (Int, Int)
-spanSize ss = (srcSpanEndLine ss - srcSpanStartLine ss, max 0 (srcSpanEndColumn ss - srcSpanStartColumn ss))
-
--- | An entity located in the source.
-data Loc a = Loc
-    { loc :: SrcSpan
-    , unLoc :: a
-    }
-  deriving (Eq,Ord,Show)
-
-
--- | A portion of the source, extended with information on the position of entities within the span.
-data SrcSpanInfo = SrcSpanInfo
-    { srcInfoSpan    :: SrcSpan
---    , explLayout     :: Bool
-    , srcInfoPoints  :: [SrcSpan]    -- Marks the location of specific entities inside the span
-    }
-#ifdef __GLASGOW_HASKELL__
-  deriving (Eq,Ord,Show,Typeable,Data)
-#else
-  deriving (Eq,Ord,Show)
-#endif
-
--- | Generate a 'SrcSpanInfo' with no positional information for entities.
-noInfoSpan :: SrcSpan -> SrcSpanInfo
-noInfoSpan ss = SrcSpanInfo ss []
-
--- | Generate a 'SrcSpanInfo' with the supplied positional information for entities.
-infoSpan :: SrcSpan -> [SrcSpan] -> SrcSpanInfo
-infoSpan = SrcSpanInfo
-
--- | Combine two 'SrcSpanInfo's into one that spans the combined source area of
---   the two arguments, leaving positional information blank.
-combSpanInfo :: SrcSpanInfo -> SrcSpanInfo -> SrcSpanInfo
-combSpanInfo s1 s2 = SrcSpanInfo
-    (mergeSrcSpan (srcInfoSpan s1) (srcInfoSpan s2))
-    []
-
--- | Short name for 'combSpanInfo'
-(<++>) :: SrcSpanInfo -> SrcSpanInfo -> SrcSpanInfo
-(<++>) = combSpanInfo
-
--- | Optionally combine the first argument with the second,
---   or return it unchanged if the second argument is 'Nothing'.
-(<+?>) :: SrcSpanInfo -> Maybe SrcSpanInfo -> SrcSpanInfo
-a <+?> b = case b of {Nothing -> a; Just b -> a <++> b}
-
--- | Optionally combine the second argument with the first,
---   or return it unchanged if the first argument is 'Nothing'.
-(<?+>) :: Maybe SrcSpanInfo -> SrcSpanInfo -> SrcSpanInfo
-a <?+> b = case a of {Nothing -> b; Just a -> a <++> b}
-
--- | Add more positional information for entities of a span.
-(<**) :: SrcSpanInfo -> [SrcSpan] -> SrcSpanInfo
-ss@(SrcSpanInfo {srcInfoPoints = ps}) <** xs = ss {srcInfoPoints = ps ++ xs}
-
--- | Merge two 'SrcSpan's and lift them to a 'SrcInfoSpan' with
---   no positional information for entities.
-(<^^>) :: SrcSpan -> SrcSpan -> SrcSpanInfo
-a <^^> b = noInfoSpan (mergeSrcSpan a b)
-
-infixl 6 <^^>
-infixl 5 <++>
-infixl 4 <**, <+?>, <?+>
-
--- | A class to work over all kinds of source location information.
-class SrcInfo si where
-  toSrcInfo   :: SrcLoc -> [SrcSpan] -> SrcLoc -> si
-  fromSrcInfo :: SrcSpanInfo -> si
-  getPointLoc :: si -> SrcLoc
-  fileName    :: si -> String
-  startLine   :: si -> Int
-  startColumn :: si -> Int
-
-  getPointLoc si = SrcLoc (fileName si) (startLine si) (startColumn si)
-
-instance SrcInfo SrcLoc where
-  toSrcInfo s _ _ = s
-  fromSrcInfo si = SrcLoc (fileName si) (startLine si) (startColumn si)
-  fileName = srcFilename
-  startLine = srcLine
-  startColumn = srcColumn
-
-instance SrcInfo SrcSpan where
-  toSrcInfo st _ end = mkSrcSpan st end
-  fromSrcInfo = srcInfoSpan
-  fileName = srcSpanFilename
-  startLine = srcSpanStartLine
-  startColumn = srcSpanStartColumn
-
-instance SrcInfo SrcSpanInfo where
-  toSrcInfo st pts end = SrcSpanInfo (mkSrcSpan st end) pts
-  fromSrcInfo = id
-  fileName = fileName . srcInfoSpan
-  startLine = startLine . srcInfoSpan
-  startColumn = startColumn . srcInfoSpan
+{-# LANGUAGE CPP, DeriveDataTypeable #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  Language.Haskell.Exts.SrcLoc+-- Copyright   :  (c) Niklas Broberg 2009+-- License     :  BSD-style (see the file LICENSE.txt)+--+-- Maintainer  :  Niklas Broberg, d00nibro@chalmers.se+-- Stability   :  stable+-- Portability :  portable+--+-- This module defines various data types representing source location+-- information, of varying degree of preciseness.+--+-----------------------------------------------------------------------------+module Language.Haskell.Exts.SrcLoc where++#ifdef __GLASGOW_HASKELL__+#ifdef BASE4+import Data.Data+#else+import Data.Generics (Data(..),Typeable(..))+#endif+#endif++-- | A single position in the source.+data SrcLoc = SrcLoc+    { srcFilename :: String+    , srcLine :: Int+    , srcColumn :: Int+    }+#ifdef __GLASGOW_HASKELL__+  deriving (Eq,Ord,Show,Typeable,Data)+#else+  deriving (Eq,Ord,Show)+#endif++noLoc :: SrcLoc+noLoc = SrcLoc "" (-1) (-1)++-- | A portion of the source, spanning one or more lines and zero or more columns.+data SrcSpan = SrcSpan+    { srcSpanFilename    :: String+    , srcSpanStartLine   :: Int+    , srcSpanStartColumn :: Int+    , srcSpanEndLine     :: Int+    , srcSpanEndColumn   :: Int+    }+#ifdef __GLASGOW_HASKELL__+  deriving (Eq,Ord,Show,Typeable,Data)+#else+  deriving (Eq,Ord,Show)+#endif+++-- | Returns 'srcSpanStartLine' and 'srcSpanStartColumn' in a pair.+srcSpanStart :: SrcSpan -> (Int,Int)+srcSpanStart x = (srcSpanStartLine x, srcSpanStartColumn x)++-- | Returns 'srcSpanEndLine' and 'srcSpanEndColumn' in a pair.+srcSpanEnd :: SrcSpan -> (Int,Int)+srcSpanEnd x = (srcSpanEndLine x, srcSpanEndColumn x)+++-- | Combine two locations in the source to denote a span.+mkSrcSpan :: SrcLoc -> SrcLoc -> SrcSpan+mkSrcSpan (SrcLoc fn sl sc) (SrcLoc _ el ec) = SrcSpan fn sl sc el ec++-- | Merge two source spans into a single span from the start of the first+--   to the end of the second. Assumes that the two spans relate to the+--   same source file.+mergeSrcSpan :: SrcSpan -> SrcSpan -> SrcSpan+mergeSrcSpan (SrcSpan fn sl1 sc1 el1 ec1) (SrcSpan _ sl2 sc2 el2 ec2) = +    let (sl,sc) = min (sl1,sc1) (sl2,sc2)+        (el,ec) = max (el1,ec1) (el2,ec2)+     in SrcSpan fn sl sc el ec++-- | Test if a given span starts and ends at the same location.+isNullSpan :: SrcSpan -> Bool+isNullSpan ss = spanSize ss == (0,0)+{- isNullSpan ss = srcSpanStartLine ss == srcSpanEndLine ss &&+                    srcSpanStartColumn ss >= srcSpanEndColumn ss+-}++spanSize :: SrcSpan -> (Int, Int)+spanSize ss = (srcSpanEndLine ss - srcSpanStartLine ss, max 0 (srcSpanEndColumn ss - srcSpanStartColumn ss))++-- | An entity located in the source.+data Loc a = Loc+    { loc :: SrcSpan+    , unLoc :: a+    }+  deriving (Eq,Ord,Show)+++-- | A portion of the source, extended with information on the position of entities within the span.+data SrcSpanInfo = SrcSpanInfo+    { srcInfoSpan    :: SrcSpan+--    , explLayout     :: Bool+    , srcInfoPoints  :: [SrcSpan]    -- Marks the location of specific entities inside the span+    }+#ifdef __GLASGOW_HASKELL__+  deriving (Eq,Ord,Show,Typeable,Data)+#else+  deriving (Eq,Ord,Show)+#endif++-- | Generate a 'SrcSpanInfo' with no positional information for entities.+noInfoSpan :: SrcSpan -> SrcSpanInfo+noInfoSpan ss = SrcSpanInfo ss []++-- | Generate a 'SrcSpanInfo' with the supplied positional information for entities.+infoSpan :: SrcSpan -> [SrcSpan] -> SrcSpanInfo+infoSpan = SrcSpanInfo++-- | Combine two 'SrcSpanInfo's into one that spans the combined source area of+--   the two arguments, leaving positional information blank.+combSpanInfo :: SrcSpanInfo -> SrcSpanInfo -> SrcSpanInfo+combSpanInfo s1 s2 = SrcSpanInfo+    (mergeSrcSpan (srcInfoSpan s1) (srcInfoSpan s2))+    []++-- | Short name for 'combSpanInfo'+(<++>) :: SrcSpanInfo -> SrcSpanInfo -> SrcSpanInfo+(<++>) = combSpanInfo++-- | Optionally combine the first argument with the second,+--   or return it unchanged if the second argument is 'Nothing'.+(<+?>) :: SrcSpanInfo -> Maybe SrcSpanInfo -> SrcSpanInfo+a <+?> b = case b of {Nothing -> a; Just b -> a <++> b}++-- | Optionally combine the second argument with the first,+--   or return it unchanged if the first argument is 'Nothing'.+(<?+>) :: Maybe SrcSpanInfo -> SrcSpanInfo -> SrcSpanInfo+a <?+> b = case a of {Nothing -> b; Just a -> a <++> b}++-- | Add more positional information for entities of a span.+(<**) :: SrcSpanInfo -> [SrcSpan] -> SrcSpanInfo+ss@(SrcSpanInfo {srcInfoPoints = ps}) <** xs = ss {srcInfoPoints = ps ++ xs}++-- | Merge two 'SrcSpan's and lift them to a 'SrcInfoSpan' with+--   no positional information for entities.+(<^^>) :: SrcSpan -> SrcSpan -> SrcSpanInfo+a <^^> b = noInfoSpan (mergeSrcSpan a b)++infixl 6 <^^>+infixl 5 <++>+infixl 4 <**, <+?>, <?+>++-- | A class to work over all kinds of source location information.+class SrcInfo si where+  toSrcInfo   :: SrcLoc -> [SrcSpan] -> SrcLoc -> si+  fromSrcInfo :: SrcSpanInfo -> si+  getPointLoc :: si -> SrcLoc+  fileName    :: si -> String+  startLine   :: si -> Int+  startColumn :: si -> Int++  getPointLoc si = SrcLoc (fileName si) (startLine si) (startColumn si)++instance SrcInfo SrcLoc where+  toSrcInfo s _ _ = s+  fromSrcInfo si = SrcLoc (fileName si) (startLine si) (startColumn si)+  fileName = srcFilename+  startLine = srcLine+  startColumn = srcColumn++instance SrcInfo SrcSpan where+  toSrcInfo st _ end = mkSrcSpan st end+  fromSrcInfo = srcInfoSpan+  fileName = srcSpanFilename+  startLine = srcSpanStartLine+  startColumn = srcSpanStartColumn++instance SrcInfo SrcSpanInfo where+  toSrcInfo st pts end = SrcSpanInfo (mkSrcSpan st end) pts+  fromSrcInfo = id+  fileName = fileName . srcInfoSpan+  startLine = startLine . srcInfoSpan+  startColumn = startColumn . srcInfoSpan
src/Language/Haskell/Exts/Syntax.hs view
@@ -86,7 +86,7 @@     unit_con, tuple_con, unboxed_singleton_con,     -- ** Special identifiers     as_name, qualified_name, hiding_name, minus_name, bang_name, dot_name, star_name,-    export_name, safe_name, unsafe_name, threadsafe_name, +    export_name, safe_name, unsafe_name, threadsafe_name,     stdcall_name, ccall_name, cplusplus_name, dotnet_name, jvm_name, js_name,     forall_name, family_name,     -- ** Type constructors@@ -330,7 +330,7 @@      -- ^ An INLINE pragma      | InlineConlikeSig SrcLoc      Activation QName      -- ^ An INLINE CONLIKE pragma-     | SpecSig          SrcLoc                 QName [Type]+     | SpecSig          SrcLoc      Activation QName [Type]      -- ^ A SPECIALISE pragma      | SpecInlineSig    SrcLoc Bool Activation QName [Type]      -- ^ A SPECIALISE INLINE pragma@@ -605,8 +605,8 @@                                 --   the last statement in the list                                 --   should be an expression.     | MDo [Stmt]                -- ^ @mdo@-expression-    | Tuple [Exp]               -- ^ tuple expression-    | TupleSection [Maybe Exp]  -- ^ tuple section expression, e.g. @(,,3)@+    | Tuple Boxed [Exp]         -- ^ tuple expression+    | TupleSection Boxed [Maybe Exp]  -- ^ tuple section expression, e.g. @(,,3)@     | List [Exp]                -- ^ list expression     | Paren Exp                 -- ^ parenthesised expression     | LeftSection Exp QOp       -- ^ left section @(@/exp/ /qop/@)@@@ -706,6 +706,7 @@ data Safety     = PlayRisky         -- ^ unsafe     | PlaySafe Bool     -- ^ safe ('False') or threadsafe ('True')+    | PlayInterruptible -- ^ interruptible #ifdef __GLASGOW_HASKELL__   deriving (Eq,Ord,Show,Typeable,Data) #else@@ -720,6 +721,7 @@     | DotNet     | Jvm     | Js+    | CApi #ifdef __GLASGOW_HASKELL__   deriving (Eq,Ord,Show,Typeable,Data) #else@@ -789,7 +791,7 @@     | PNPlusK Name Integer          -- ^ n+k pattern     | PInfixApp Pat QName Pat       -- ^ pattern with an infix data constructor     | PApp QName [Pat]              -- ^ data constructor and argument patterns-    | PTuple [Pat]                  -- ^ tuple pattern+    | PTuple Boxed [Pat]            -- ^ tuple pattern     | PList [Pat]                   -- ^ list pattern     | PParen Pat                    -- ^ parenthesized pattern     | PRec QName [PatField]         -- ^ labelled pattern, record style@@ -979,7 +981,7 @@ dot_name       = Symbol "." star_name      = Symbol "*" -export_name, safe_name, unsafe_name, threadsafe_name, +export_name, safe_name, unsafe_name, threadsafe_name,   stdcall_name, ccall_name, cplusplus_name, dotnet_name,   jvm_name, js_name, forall_name, family_name :: Name export_name     = Ident "export"